C# kann Nicht beheben symbol

Ich weiß nicht, warum ich immer diese Fehlermeldung. Scheint elementar. Trotzdem habe ich eine singleton-Klasse namens EmailSender. Der code ist kurz und einfach. Das Problem ist, dass ich nicht verwenden können sender in der MainWindow-Klasse. Alles, was ich versuchen, diese als Absender.Send() wird behandelt, als ob ich getan habe, asdafsafas.Senden(). Es behandelt, als ob es eine zufällige Zeichenfolge von Zeichen. Weiß nicht, warum dies geschieht.

using System;
using System.Net.Mail;
using System.Windows.Forms;

namespace SendMail
{
    public partial class MainWindow : Form
    {
        #region Private variables
        private MailMessage msg = new MailMessage();
        private EmailSender sender = EmailSender.GetInstance();
        #endregion

        public MainWindow()
        {
            InitializeComponent();

        }

        private MailMessage PrepareMailMessage()
        {

            return msg;
        }

        private void btnSend_Click(object sender, EventArgs e)
        {

        }
    }
}

Hier ist die GetInstance-Methode:

public static EmailSender GetInstance()
{
    return _instance ?? (_instance = new EmailSender());
}

Was ist die genaue Fehlermeldung?
Cannot resolve symbol Absender. Wenn ich kompilieren, ich bekomme die Meldung: Ungültiges token '(' in class, struct, or interface member declaration im Hauptfenster.cs
Okay, und die Zeile nicht produzieren diese Fehlermeldung?
Das singleton ist nicht threadsicher.
Gut, in einer einfachen Windows Forms-Programm, das ist wahrscheinlich nicht ein Problem.

InformationsquelleAutor s5s | 2011-11-04

.net c#resolve singleton symbols

6

Dies ist wegen der Art, wie Sie diese Methode definiert (sender ist ein parameter). Es ist das finden der Methode argument ersten, nicht deine Klasse-variable. Sie können sich diese:
```
private void btnSend_Click(object sender, EventArgs e)
{
    //sender here is the "(object sender, " paramater, so it's defined
    //as system object.

    //use this instead:
    this.sender.Send(); //The "this" will make the class find the instance level variable instead of using the "object sender" argument
}
```
OK, ich sehe. Oh, ich vergaß über das sender-Objekt. Ich bin versucht zu überarbeiten meiner C# und danke.
Eine einfache Problemumgehung ist, zu Folgen, Konventionen und Präfix private Variablen, die mit _. Ex: _sender
Oder, alternativ, in die Gewohnheit, nach dem StyleCop Richtlinien, die darauf hindeuten, immer voranstellen Mitglied Zugang über this.***.

InformationsquelleAutor Reed Copsey

Weil sender ist keine E-mail-Objekt, sondern die Schaltfläche, die das Ereignis ausgelöst hat. Sie müssen die SmtpClient zum senden der E-Mail:

private void btnSend_Click(object sender, EventArgs e)  
{  
    SmtpClient client = new SmtpClient("192.0.0.1", 25); //host, port
    client.Send(msg);
}

Auch, die MailMessage Klasse implementiert IDisposable, so müssen Sie einige code zu entsorgen die Nachricht sobald Sie fertig sind mit ihm.

Erstellte ich einen wrapper, der alles enthält, was Sie benötigen, um emails zu versenden, einschließlich der Entsorgung:

///<summary>
///Wrapper class for the System.Net.Mail objects
///</summary>
public class SmtpMailMessage : IDisposable
{
    #region declarations

    MailMessage Message;
    SmtpClient SmtpMailClient;

    #endregion

    #region constructors

    ///<summary>
    ///Default constructor for the SmtpMailMessage class
    ///</summary>
    public SmtpMailMessage()
    {
        //initialize the mail message
        Message = new MailMessage();
        Message.Priority = MailPriority.Normal;
        Message.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure;            
        Message.From = new MailAddress("[email protected]");           

        //initialize the smtp client
        SmtpMailClient = new SmtpClient();
        SmtpMailClient.DeliveryMethod = SmtpDeliveryMethod.Network;
        SmtpMailClient.Host = "192.168.0.1";
        SmtpMailClient.Port = 25;
    }

    ///<summary>
    ///Parameterized constructor for the SmtpMailMessage class. Allows for override of the default
    ///SMTP host and port number
    ///</summary>
    ///<param name="HostIP">The IP address of the exchange server</param>
    ///<param name="PortNumber">The port number for ingoing and outgoing SMTP messages</param>
    public SmtpMailMessage(string HostIP, int PortNumber) : this()
    {
        //override the smtp host value
        SmtpMailClient.Host = HostIP;

        //override the smtp port value
        SmtpMailClient.Port = PortNumber;
    }

    #endregion

    #region subject /body

    ///<summary>
    ///The body content of the mail message
    ///</summary>
    public string Body
    {
        get
        {
            return Message.Body;
        }
        set
        {
            Message.Body = value;
        }
    }

    ///<summary>
    ///the subject of the mail message
    ///</summary>
    public string Subject
    {
        get
        {
            return Message.Subject;
        }
        set
        {
            Message.Subject = value;
        }
    }

    #endregion

    #region mail type

    ///<summary>
    ///Gets or sets a value that determines whether the mail message
    ///should be formatted as HTML or text
    ///</summary>
    public bool IsHtmlMessage
    {
        get
        {
            return Message.IsBodyHtml;
        }
        set
        {
            Message.IsBodyHtml = value;
        }
    }

    #endregion

    #region sender

    ///<summary>
    ///Gets or sets the from address of this message
    ///</summary>
    public string From
    {
        get
        {
            return Message.From.Address;
        }
        set
        {
            Message.From = new MailAddress(value);
        }
    }

    #endregion

    #region recipients

    ///<summary>
    ///Gets the collection of recipients
    ///</summary>
    public MailAddressCollection To
    {
        get
        {
            return Message.To;

        }
    }

    ///<summary>
    ///Gets the collection of CC recipients 
    ///</summary>
    public MailAddressCollection CC
    {
        get
        {
            return Message.CC;
        }
    }

    ///<summary>
    ///Gets the collection of Bcc recipients
    ///</summary>
    public MailAddressCollection Bcc
    {
        get
        {
            return Message.Bcc;
        }
    }

    #endregion

    #region delivery notification

    ///<summary>
    ///Gets or sets the delivery notification settings for this message
    ///</summary>
    public DeliveryNotificationOptions DeliveryNotifications
    {
        get
        {
            return Message.DeliveryNotificationOptions;
        }
        set
        {
            Message.DeliveryNotificationOptions = value;
        }
    }

    #endregion

    #region priority

    ///<summary>
    ///Gets or sets the Priority of this message
    ///</summary>
    public MailPriority PriorityLevel
    {
        get
        {
            return Message.Priority;
        }
        set
        {
            Message.Priority = value;
        }
    }

    #endregion

    #region send methods

    ///<summary>
    ///Sends the message anonymously (without credentials)
    ///</summary>
    public void Send()
    {
        SmtpMailClient.Send(Message);
    }

    ///<summary>
    ///Sends the message with authorization from a network account   
    ///</summary>
    ///<param name="Username">The Windows username of the authorizing user</param>
    ///<param name="Password">The Windows password of the authorizing user</param>
    ///<param name="Domain">The domain name of the network to which the authorizing user belongs</param>
    public void Send(string Username, string Password, string Domain)
    {
        //attach a network credential to this message using the information passed into the method
        SmtpMailClient.Credentials = new NetworkCredential(Username, Password, Domain);

        //send the message
        SmtpMailClient.Send(Message);
    }

    #endregion

    #region IDisposable implementation

    ~SmtpMailMessage()
    {
        Dispose(false);
    }

    public void Dispose()
    {
        Dispose(true);            
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (Message != null)
                Message.Dispose();
            Message = null;                
            SmtpMailClient = null;
        }
    }

    #endregion        
}

Umsetzung:

using (SmtpMailMessage mail = new SmtpMailMessage("192.168.0.1", 25))
{
    //set the to address to the primary email
    mail.To.Add("[email protected]");

    //set the message type and subject and body
    mail.IsHtmlMessage = true;
    mail.Subject = "Foo";
    mail.Body = "Hello world!";

    //send the email
    mail.Send();
}

InformationsquelleAutor James Johnson

0

Wenn Sie es tun, innerhalb des Rahmens Ihrer btnSend_Click Methode, die parameter object sender Vorrang vor der globalen EmailSender sender.

Sollten Sie entweder benennen Sie die Globale variable, z.B.: EmailSender m_sender oder genau angeben, welche sender Sie wollen: this.sender.Send()

InformationsquelleAutor rrhartjr
0

Ich Schätze, dass Sie den Absender anrufen.Senden Sie in der btnSend_Click Funktion.

In dieser Funktion wird ein param-auch als Absender (object sender). Jetzt können Sie code ist verwirrt, die man zu verwenden. So benennen Sie Ihre private var Absender.

InformationsquelleAutor SynerCoder

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.