Apelarea constructor de bază în C#
Dacă am moștenit de la o clasă de bază și doresc să treacă ceva de la constructorul a moștenit clasa a constructorului din clasa de baza, cum fac asta?
De exemplu,
Dacă am moștenit de Excepție clasă vreau să fac ceva de genul asta:
class MyExceptionClass : Exception
{
public MyExceptionClass(string message, string extraInfo)
{
//This is where it's all falling apart
base(message);
}
}Practic, ceea ce vreau este de a fi capabil de a trece string mesaj de la baza Excepție de clasă.
Modifica constructor la următoarea, astfel încât se numește clasă de bază constructor în mod corespunzător:
public class MyExceptionClass : Exception
{
public MyExceptionClass(string message, string extrainfo) : base(message)
{
//other stuff here
}
}Rețineți că un constructor nu este ceva la care poți apela oricând într-o metodă. Ca's motivul pentru care ai're obtinerea erori în apel în constructorul corpului.
Rețineți că puteți utiliza static metode cadrul apelului de constructor de bază.
class MyExceptionClass : Exception
{
public MyExceptionClass(string message, string extraInfo) :
base(ModifyMessage(message, extraInfo))
{
}
private static string ModifyMessage(string message, string extraInfo)
{
Trace.WriteLine("message was " + message);
return message.ToLowerInvariant() + Environment.NewLine + extraInfo;
}
}
Dacă aveți nevoie pentru a apela constructor de bază, dar nu imediat, pentru că noi (derivate) clasa are nevoie pentru a face unele de manipulare a datelor, cea mai bună soluție este de a recurge la metoda fabrică. Ceea ce trebuie să faceți este de a marca privat derivate constructor, apoi face o metodă statică din clasa ta, care va face toate lucrurile necesare și mai târziu apela constructorul și a reveni la obiect.
public class MyClass : BaseClass
{
private MyClass(string someString) : base(someString)
{
//your code goes in here
}
public static MyClass FactoryMethod(string someString)
{
//whatever you want to do with your string before passing it in
return new MyClass(someString);
}
}
Este adevărat folosi "de bază" (ceva) pentru a apela clasa de baza constructorul, dar în caz de supraîncărcare a folosi "această" cheie
public ClassName() : this(par1,par2)
{
// do not call the constructor it is called in the this.
// the base key- word is used to call a inherited constructor
}
// Hint used overload as often as needed do not write the same code 2 or more times
Din Cadru liniile Directoare de Proiectare și FxCop reguli.:
1. Personalizat Excepție ar trebui să aibă un nume care se termină cu Excepția
class MyException : Exception2. Excepție ar trebui să fie publice
public class MyException : Exception3. CA1032: Excepție ar trebui să implementeaza standardul constructori.
- O publice parameterless constructor.
- Un constructor publice cu un șir de argumente.
- Un constructor publice cu o singură coardă și de Excepție (cum se poate încadra o altă Excepție).
- O serialization constructor protejate în cazul în care tipul nu este sigilat și privat în cazul în care tipul este sigilat. Bazat pe MSDN:
[Serializable()] public class MyException : Excepție { public MyException() { // Adauga orice tip specific de logică, și de aprovizionare mesajul implicit. }
public MyException(string mesaj): base(mesaj) { // Adauga orice tip-specifice logica. } public MyException(string mesaj, Excepție innerException): de bază (mesaj, innerException) { // Adauga orice tip-specifice logica pentru interior excepții. } protejate MyException(SerializationInfo info, StreamingContext context) : baza(informatii, context) { // Pune în aplicare specifice tipului de serialization constructor logica. } }
sau
[Serializable()]
public sealed class MyException : Exception
{
public MyException()
{
// Add any type-specific logic, and supply the default message.
}
public MyException(string message): base(message)
{
// Add any type-specific logic.
}
public MyException(string message, Exception innerException):
base (message, innerException)
{
// Add any type-specific logic for inner exceptions.
}
private MyException(SerializationInfo info,
StreamingContext context) : base(info, context)
{
// Implement type-specific serialization constructor logic.
}
} 
Puteți face, de asemenea, condiționată verifica cu parametrii în constructor, care permite o oarecare flexibilitate.
public MyClass(object myObject=null): base(myObject ?? new myOtherObject())
{
}sau
public MyClass(object myObject=null): base(myObject==null ? new myOtherObject(): myObject)
{
}
Ca pe unele de celelalte răspunsuri enumerate aici, puteți trece parametrii în baza constructorul clasei. Este recomandat pentru a apela dumneavoastră de bază constructorul clasei la începutul constructor pentru a moștenit de clasă.
public class MyException : Exception
{
public MyException(string message, string extraInfo) : base(message)
{
}
}Am act de faptul că, în exemplul tău niciodată nu a făcut uz de extraInfo parametru, deci am presupus că ai vrea să înlănțui pe extraInfo parametru șir la Mesajul proprietate de excepție (se pare că acest lucru este ignorat în răspunsul acceptat și codul în cauză).
Acest lucru este pur și simplu realizat prin invocarea clasa de baza constructorul, și apoi actualizarea Mesaj de proprietate cu informatii suplimentare.
public class MyException: Exception
{
public MyException(string message, string extraInfo) : base($"{message} Extra info: {extraInfo}")
{
}
}
class Exception
{
public Exception(string message)
{
[...]
}
}
class MyExceptionClass : Exception
{
public MyExceptionClass(string message, string extraInfo)
: base(message)
{
[...]
}
}
public class MyException : Exception
{
public MyException() { }
public MyException(string msg) : base(msg) { }
public MyException(string msg, Exception inner) : base(msg, inner) { }
}
