3.920 messaggi dal 28 gennaio 2003
Moreno, tu sai benissimo che il tuo codice funziona benissimo, e non aspetterò certo che la correzione venga ufficializzata.
Bravo.

ps. soprattutto per aver detto come l'hai implementata

Pietro
11.881 messaggi dal 09 febbraio 2002
Contributi
Pietro, grazie per la fiducia :D
Però tieni presente che ogni persona è fallibile, indipendentemente dall'esperienza che ha. Anzi, l'esperienza a volte dà un senso di falsa sicurezza e porta a commettere leggerezze.

Enjoy learning and just keep making
3.920 messaggi dal 28 gennaio 2003
Anche se sono in ferie, per puro divertimento, ho provato ad aggiungere qualche costruttore per esempio:
public MimeAttachment(Stream contentStream, string name)
public MimeAttachment(Byte[] buffer, string name)

La compilazione con vs2017 non segnala errori, ma la libreria usata in un progetto web con vs2010,
segnala come errore

allegato = New MimeAttachment(ms, "messaggio1.txt")
ma solo in visualizzazione, perchè la compilazione e il lancio della pagina non dà problemi.

Dato che non conosco bene c#, ma un po' vb.net, cosa sbaglio?

using System;
using System.IO;
using System.Net.Mail;
using System.Net.Mime;

namespace AegisImplicitMail
{

    /// <summary>
    /// Class for holding an attachment's information.
    /// </summary>
    public class MimeAttachment : Attachment
    {
        #region properties
        internal static int InlineCount;
        internal static int AttachCount;
        private AttachmentLocation _location;
        /// <summary>
        /// File to send.
        /// </summary>
        public string FileName;
        /// <summary>
        /// Content type of file (application/octet-stream for regular attachments).
        /// </summary>
        //    public ContentType ContentType;

        /// <summary>
        /// Where to put the attachment.
        /// </summary>
        public AttachmentLocation Location
        {
            get { return _location; }
            set
            {
                if (value == AttachmentLocation.Attachmed)
                {
                    ++AttachCount;
                }
                else if (value == AttachmentLocation.Inline)
                {
                    ++InlineCount;
                }
                else
                {
                    throw new Exception("Invalid location.");
                }
                _location = value;
            }
        }

        #endregion

        #region Constructors
        /// <summary>
        /// Default constructor.
        /// </summary>
        //    public SmtpAttachment():base(){}

        /// <summary>
        /// Constructor for passing all information at once.
        /// </summary>
        /// <param name="fileName">File to send.</param>
        /// <param name="contentType">Content type of file (application/octet-stream for regular attachments.)</param>
        /// <param name="location">Where to put the attachment.</param>
        public MimeAttachment(string fileName, ContentType contentType, AttachmentLocation location)
            : base(fileName)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException(nameof(fileName));
            }
            FileName = fileName;
            ContentType = contentType;
            Location = location;
        }


        /// <summary>
        /// Shortcut constructor for passing regular style attachments.
        /// </summary>
        /// <param name="filename">File to send.</param>
        public MimeAttachment(string filename)
            : this(filename, new ContentType(MediaTypeNames.Application.Octet), AttachmentLocation.Attachmed)
        {
            Location = Location;
        }



        /// <summary>
        /// Constructor for passing stream attachments.
        /// </summary>
        /// <param name="contentStream">Stream to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        /// <param name="location">Where to put the attachment</param>
        public MimeAttachment(Stream contentStream, string name, AttachmentLocation location = AttachmentLocation.Attachmed)
            : this(contentStream, name, new ContentType(MediaTypeNames.Application.Octet), location)
        {
        }

        /// <summary>
        /// Constructor for passing stream attachments.
        /// </summary>
        /// <param name="contentStream">Stream to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        /// <param name="contentType">Content type of the attachment</param>
        /// <param name="location">Where to put the attachment</param>
        public MimeAttachment(Stream contentStream, string name, ContentType contentType, AttachmentLocation location = AttachmentLocation.Attachmed)
            : base(contentStream, name)
        {
            Location = location;
            ContentType = contentType;
        }

        /// <summary>
        /// Shortcut constructor for passing regular style attachments.
        /// </summary>
        /// <param name="contentStream">Stream to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        public MimeAttachment(Stream contentStream, string name)
            : this(contentStream, name, new ContentType(MediaTypeNames.Application.Octet), AttachmentLocation.Attachmed)
        {
            Location = Location;
        }

        /// <summary>
        /// Constructor for passing buffer attachments.
        /// </summary>
        /// <param name="buffer">Buffer to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        public MimeAttachment(Byte[] buffer, string name)
            : this(new MemoryStream(buffer), name, new ContentType(MediaTypeNames.Application.Octet), AttachmentLocation.Attachmed)
        {
            Location = Location;
        }


        /// <summary>
        /// Constructor for passing buffer attachments.
        /// </summary>
        /// <param name="buffer">Buffer to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        /// <param name="location">Where to put the attachment</param>
        public MimeAttachment(Byte[] buffer, string name, AttachmentLocation location = AttachmentLocation.Attachmed)
            : this(new MemoryStream(buffer), name, new ContentType(MediaTypeNames.Application.Octet), location)
        {
            
        }

        /// <summary>
        /// Constructor for passing buffer attachments.
        /// </summary>
        /// <param name="buffer">Buffer to the attachment contents</param>
        /// <param name="name">Name of the attachment as it will appear on the e-mail</param>
        /// <param name="contentType">Content type of the attachment</param>
        /// <param name="location">Where to put the attachment</param>
        public MimeAttachment(Byte[] buffer, string name, ContentType contentType, AttachmentLocation location = AttachmentLocation.Attachmed)
            : base(new MemoryStream(buffer), name)
        {
            Location = location;
            ContentType = contentType;
        }





        /// <summary>
        /// Show this attachment.
        /// </summary>
        /// <returns>The file name of the attachment.</returns>
        public override string ToString()
        {
            return FileName;
        }

    }

    #endregion
    /// <summary>
    /// For use in SmtpAttachment.
    /// </summary>
    public enum AttachmentLocation
    {
        /// <summary>
        /// Send as attachment.
        /// </summary>
        Attachmed = 0,
        /// <summary>
        /// Send as MIME inline (for html images, etc).
        /// </summary>
        Inline = 1
    }


}

Pietro
11.881 messaggi dal 09 febbraio 2002
Contributi
Dunque, forse si lamenta del fatto che questo costruttore è ridondante. Che errore ti segnala precisamente?
public MimeAttachment(Stream contentStream, string name)


Infatti, c'è già un costruttore che accetta i due parametri Stream e string (più un terzo parametro opzionale). Eccolo qui. Si capisce che il terzo parametro è opzionale dal fatto che gli viene assegnato un valore di default.
public MimeAttachment(Stream contentStream, string name, AttachmentLocation location = AttachmentLocation.Attachmed)
            : this(contentStream, name, new ContentType(MediaTypeNames.Application.Octet), location)
        {
        }




Quindi questo costruttore può essere invocato sia così:
var attachment = new MimeAttachment(ms, "nomefile.txt");


che così:
var attachment = new MimeAttachment(ms, "nomefile.txt", AttachmentLocation.Attachmed);


Altra cosa... In quest'altro costruttore invece:
public MimeAttachment(Byte[] buffer, string name)

Attenzione perché questo costruttore crea lui stesso un MemoryStream e quindi avrà lui l'onere di distruggerlo invocando il metodo Dispose. Altrimenti avrai un memory leak. Lo puoi invocare nel Dispose della classe MimeAttachment ma... a quel punto ti serve un modo per distinguere lo stream che hai creato tu da quello che ti è stato passato da fuori dall'utente della classe.

ciao,
Moreno
Modificato da BrightSoul il 22 luglio 2018 18.15 -

Enjoy learning and just keep making
3.920 messaggi dal 28 gennaio 2003
Ti ringrazio.
Mi studierò con calma la tua risposta.
Ciao.

Se faccio un progettino di prova con vs2017 vedo che non c'è problema.
Il problema è solo se uso la dll con un sito web fatto con vs2010. Pur funzionando, il codice risulta sottolineato in blu. Non riconosce le diverse versioni di overload delle procedure.
Ciao ancora

Pietro
11.881 messaggi dal 09 febbraio 2002
Contributi
Può darsi che la funzionalità dei parametri opzionali sia stata introdotta dopo il rilascio di VS2010 e quindi l'intellisense fa difficoltà. Non mi ricordo esattamente...

Enjoy learning and just keep making
3.920 messaggi dal 28 gennaio 2003
BrightSoul ha scritto:
Può darsi che la funzionalità dei parametri opzionali sia stata introdotta dopo il rilascio di VS2010 e quindi l'intellisense fa difficoltà. Non mi ricordo esattamente...


No, per niente. E' che sono io il pasticcione. E' bastato togliere quel codice che ho scritto per vedere che funziona!!!

Però era simpatico potergli mandare pure un buffer di byte

ciao

Pietro

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.