La classe dell'array in C # - Domande di implementazione

Question

La classe dell'array in C # - Domande di implementazione

#1 da (8 voti)

3

Sto studiando la classe Array in C #. Quanto segue è l'implementazione della classe System.Array :

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public abstract class Array : ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Ho due domande a riguardo:

Ho letto che System.Array è derivata da System.Object . Ma perché questo non è visto nella definizione sopra?
ICloneable è implementato per consentire alla matrice di essere sottoposta a una copia profonda in caso di serializzazione XML. ICloneable fornisce solo un metodo: Clone (). Qual è il vantaggio di implementare esplicitamente ICloneable? Perché il metodo Clone () non può essere implementato direttamente? È questo un tipo di fornire un pattern di Interfaccia di Marcatura dove una particolare Interfaccia è implementata solo per trasmettere una certa caratteristica della classe?

c# array .net

posta TheSilverBullet 18.02.2013 - 11:26

fonte

1 risposta

Leggi altre domande sui tag c# array .net

Imparare YACC al giorno d'oggi, ha senso? [chiuso] Come risolvere i fondamenti negativi? [chiuso]

score 8 · Accepted Answer

System.Array è effettivamente derivato da System.Object . Non lo vedi qui, perché tutto in .NET Framework deriva per impostazione predefinita da System.Object , inclusi tipi come int ( System.Int32 ).

In altre parole:
- class MyClass : MyOtherClass { } indica che MyClass è derivato da MyOtherClass .
- class MyClass { } indica che MyClass è derivato da System.Object .
Il vantaggio di usare un'interfaccia è che i metodi (o le classi con generici) possono fare affidamento sulle interfacce quando hanno bisogno di un metodo o di una proprietà specifici. Immagina il seguente codice sorgente:
```
public interface INamed
{
    string Name { get; }
}

public void SayHello(INamed namedEntity)
{
    Console.WriteLine("Hello, " + namedEntity.Name + "!");
}
```
Usando un'interfaccia, il metodo mostra che non gli interessa il tipo esatto di namedEntity . Tutto ciò che importa è che l'oggetto debba contenere una proprietà di tipo string chiamata Name che ha un getter.

Il tipo effettivo potrebbe essere un Person . O un Cat : Animal . O un AircraftModel . SayHello li accetta tutti, a condizione che implementino INamed .

Perché Person implementa un'interfaccia, invece di contenere semplicemente la proprietà Name ?

Perché, a parte usando Reflection o la programmazione dinamica, il chiamante non ha idea che Person implementa effettivamente la proprietà Name . Ad esempio questo codice non verrà compilato:
```
public class Person
{
    public string Name { get; set; }
}

public void SayHello(object namedEntity)
{
    Console.WriteLine("Hello, " + namedEntity.Name + "!"); // Compile-time error here
}

public void Main()
{
    this.SayHello(new Person { Name = "Robert" });
}
```