Mail-Anhänge mit Hilfe von C# und late binding zu einem memo hinzufügen

[nobana81]

Hallo,

ich möchte gerne mit C# und OLE automation classes Mailabanhänge zu einem memo hinzufügen und anschließend dieses memo anzeigen. Da ich auf die UI-Objekte von Notes zugreife (memo anzeigen) kann ich das nicht mit COM-Aufrufe machen.

Ich habe schon sehr lange und intensiv recherchiert und kann jetzt auch ein memo erstellen und anschließend anzeigen (mit Hilfe von late binding) siehe code unten. Was ich noch nicht geschafft habe ist einen Anhang zu dem erstellen memo hinzuzufügen.
Ich würde mich sehr freuen wenn jemand das schon mal gemacht hat und mir meinen Code ergänzen könnte:

// Root ole automation Klassen holen über late binding
Type NotesSession = Type.GetTypeFromProgID("Notes.NotesSession");
Type NotesUIWorkspace = Type.GetTypeFromProgID("Notes.NotesUIWorkspace");
Object sess = Activator.CreateInstance(NotesSession);
Object ws = Activator.CreateInstance(NotesUIWorkspace);

// Mailsystem-Eigenschaften setzen
String mailServer = (String)NotesSession.InvokeMember("GetEnvironmentString", BindingFlags.InvokeMethod, null, sess, new Object[] { "MailServer", true });
String mailFile = (String)NotesSession.InvokeMember("GetEnvironmentString", BindingFlags.InvokeMethod, null, sess, new Object[] { "MailFile", true });
NotesUIWorkspace.InvokeMember("OpenDatabase", BindingFlags.InvokeMethod, null, ws, new Object[] { mailServer, mailFile });
Object uidb = NotesUIWorkspace.InvokeMember("GetCurrentDatabase", BindingFlags.InvokeMethod, null, ws, null);
Object db = NotesUIWorkspace.InvokeMember("Database", BindingFlags.GetProperty, null, uidb, null);
Type NotesDatabase = db.GetType();

// Memo erstellen
Object uidoc = NotesUIWorkspace.InvokeMember("ComposeDocument", BindingFlags.InvokeMethod, null, ws, new Object[] { mailServer, mailFile, "Memo", 0, 0, true });
Type NotesUIDocument = uidoc.GetType();
NotesUIDocument.InvokeMember("FieldSetText", BindingFlags.InvokeMethod, null, uidoc, new Object[] { "EnterSendTo", "max1@web.de" });
NotesUIDocument.InvokeMember("FieldSetText", BindingFlags.InvokeMethod, null, uidoc, new Object[] { "EnterCopyTo", "musterman@web.de" });
NotesUIDocument.InvokeMember("FieldSetText", BindingFlags.InvokeMethod, null, uidoc, new Object[] { "Subject", "Betreff" });
NotesUIDocument.InvokeMember("FieldSetText", BindingFlags.InvokeMethod, null, uidoc, new Object[] { "Body", "MailText" });

// ???Anhänge hinzufügen ??
//


// Mail anzeigen
String windowTitle = (String)NotesUIDocument.InvokeMember("WindowTitle", BindingFlags.GetProperty, null, uidoc, null);
Microsoft.VisualBasic.Interaction.AppActivate(windowTitle);

Ich konnte auch den Inhalt einer Datei in den Body vom memo schreiben siehe folgende zwei Zeilen, ich will aber die Datei als Anhang und nicht im Text:

object[] Arguments = { (System.Object)"Microsoft Word", (System.Object)@"c:\test.doc" };
object doc = NotesUIWorkspace.InvokeMember("Import", BindingFlags.InvokeMethod, null, uidoc, Arguments);


Vielen Dank im Voraus

Markus

[Hatschi]

Hallo Markus,

mit C bin ich nicht vertraut, aber vielleicht weist dir folgende Info die Richtung:
Wenn du dein Dokument erzeugt hast, kannst du ein Richtextitem erstellen. Bei einem Mail ist dass der Body. Anschließend ist mit EmbedObject die Datei anzuhängen.

Set notesEmbeddedObject = notesRichTextItem.EmbedObject( type%, class$, source$, [ name$ ] )

In der Noteshilfe findest du folgendes:
This script creates a new document in the current database, creates a new rich text item called Body on the document, and attaches the file JIM.SAM to the Body. It then sets the value of the Form and Subject items on the document and saves it.
Dim session As New NotesSession
Dim db As NotesDatabase
Dim doc As NotesDocument
Dim rtitem As NotesRichTextItem
Dim object As NotesEmbeddedObject
Set db = session.CurrentDatabase
Set doc = New NotesDocument( db )
Set rtitem = New NotesRichTextItem( doc, "Body" )
Set object = rtitem.EmbedObject _
( EMBED_ATTACHMENT, "", "c:\jim.sam")
doc.Form = "Main Topic"
doc.Subject = "Here's Jim's document, as an attachment"
Call doc.Save( True, True )

Viel Erfolg

Bernd

[nobana81]

Hallo Bernd,
danke für deine Antwort, dein Beispiel verwendet early binding aber da ich auf die Oberfläsche von Notes zugreife muss ich die Aufrufe über late binding von ole machen und nicht direkte com-aufrufe.

Zu deinem Beispiel habe ich schon den passende C#-Code (siehe unten falls es interessiert) ich muss aber leider auf die alten ole automation classes zugreifen um mein Problem zu lösen.

Funktionnierender Early Binding Code irgenwo im Netz gefunden:

NotesDocument notesDoc = CurrentNotesDatabase.CreateDocument();

notesDoc.ReplaceItemValue("Form", "Memo");
notesDoc.ReplaceItemValue("SendTo", "max1@web.de");
notesDoc.ReplaceItemValue("CopyTo", "musterman@web.de");
notesDoc.ReplaceItemValue("Subject", "Betreff");
notesDoc.SaveMessageOnSend = true;

NotesRichTextItem bodyItem = notesDoc.CreateRichTextItem("Body");
bodyItem.AppendText("Mailtext");

NotesRichTextItem attItem = notesDoc.CreateRichTextItem("Attachment");
attItem.EmbedObject(EMBED_TYPE.EMBED_ATTACHMENT, "", uniqueAttachmentName, attInfo.Value);

object oItemValue = notesDoc.GetItemValue("SendTo");
notesDoc.Send(false, ref oItemValue);


Ich freue mich auf neue Hinweise oder Code Beispiele mit late binding

Grüße
Markus

[Hatschi]

Hallo Markus,

ich habe mir deinen C code noch einmal angesehen. Dein Problem scheint nicht am late, oder early bindung zu liegen. Die Bindung ist meines erachtens nur eine Sache für den Compiler. Bei einem early binding weiß der compiler mit was für einen Objekt er es zu tun hat und kann schon während der Compilierung eine Typprüfung ausführen. Beim late bindung ist es einfach nur ein Object. Eine Typprüfung erfolgt dann erst zur Laufzeit.

Dein Problem ist vielmehr das Front, bzw. Backend. Mit Frontend ist das user interface gemeint. Pauschal sind das alle Notesobjekte die mit ui anfangen. Das Backend ist der Zugriff direkt auf die Notesdatenbank.

Jetzt aber noch einmal zu deinem Problem. Du arbeitest mit deinem Code im Frontend. Du Verwendest das Objekt NotesUIDocument. Hier ist es nicht möglich eine Datei anzuhängen. Du musst das Dokument im Backend erstellen, dann kannst du die Klasse Notesrichtext und embedObjekt verwenden um eine Datei anzuhängen.
Mir ist kein Befehl bekannt, mit dem man im Frontend per Programm eine Datei anhängen kann. Das geht nur über das Backend. Die Bindungsart spielt dabei keine Rolle.

Deine benötigten Klassen wäre
Notessession statt workspace
Notesdatabase
Notesdocument statt NotesuiDocument
Notesrichtextitem

Wenn du deinen bisherigen Code weiter verwenden möchtest, bleibt dir nur die Möglichkeit das erzeugte Dokument zu speichern. Es wieder im Backend zu öffnen und dann die Datei anzuhängen und es wieder zu speichern.
Die Verbindung zwischen dem Frontend uidocument und dem zugehörigen Backenddokument Notesdocument erfolgt über die Eigenschaft Set notesDocument = notesUIDocument.Document

Bernd

[nobana81]

Hallo Bernd,

sorry ich habe mich falsch ausgedrückt. Ich versuche es nochmal

Also wenn man programatisch auf Notes zugreifen will, dann hat man 2 Möglichkeiten entweder

-über COM Bibliotheken: kein Zugriff auf Frontend. Hier wird immer early binding verwendet (NotesSession ns = new NotesSession()...)

oder

- über OLE Bibliotheken: Zugriff auf Frontend möglich. Hier wird immer late binding verwendet (Type ns = Type.GetTypeFromProgID("Notes.NotesSession")...)

Da ich die zweite Möglichkeit brauche habe ich das halt late binding genannt:-) schade das man nicht damit Anhänge hinzufügen kann.

[Hatschi]

Bis jetzt habe ich Notes nur per COM verwendet, wenn ich es ausserhalb des Clients benötigte. Was OLE bietet, das weiss ich nicht. Im Frontend innerhalb von Notes würde ich den Befehl
@Command([EditInsertFileAttachment]) versuchen.
Nützt dir das etwas?

Bernd

[nobana81]

Es gibt meiner Meinung nach leider keine Möglichkeit Befehle mit Hilfe von OLE auszuführen.

[MaxMuster]

Moin Moin,

Da ich die zweite Möglichkeit brauche habe ich das halt late binding genannt:-) schade das man nicht damit Anhänge hinzufügen kann.

In dem von Dir geposteten Codebeispiel hast Du Zugriff auf die Notes Frontend- & Backendmethoden gehabt?

Type NotesSession = Type.GetTypeFromProgID("Notes.NotesSession");
Type NotesUIWorkspace = Type.GetTypeFromProgID("Notes.NotesUIWorkspace");

[...]
String mailFile = (String)NotesSession.InvokeMember("GetEnvironmentString", BindingFlags.InvokeMethod, null, sess, new Object[] { "MailFile", true });

Somit müsste es doch möglich sein, das Dokument im Backend vorzubereiten und dann anzuzeigen:

Im LotusScript würde man das in etwa so machen (hatte Bernd ja schon geschrieben):

Code

' Hier sind wir komplett im Backend
Dim session As New NotesSession
Dim db As NotesDatabase
Dim doc As NotesDocument
Dim rtitem As NotesRichTextItem
Dim object As NotesEmbeddedObject

Set db = session.CurrentDatabase
Set doc = New NotesDocument( db )
Set rtitem = New NotesRichTextItem( doc, "Body" )
Set object = rtitem.EmbedObject ( EMBED_ATTACHMENT, "", "c:\jim.sam") ' ' <=== ATACHMENMT 
doc.Form = "Main Topic"
doc.Subject = "Here's Jim's document, as an attachment"

' Ab gehts ins Frontend (_U_ser _I_nterface)
Dim ws as New NotesUIWorkspace
Call ws.EditDocument(False, doc)

HtH, Roger


[EDIT: Nicht gesehen, das Bernd das Gleiche schon geschrieben hatte ...  ]