Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

1

02.08.2015, 16:48

C# Wie überprüfen ob ein Typ "Built - in" ist?

Hi,

ich wollte gerne wissen, lässt sich in .NET irgendwie überprüfen, ob ein Objekt "von mir" erstellt wurde oder es von .NET ist, also bei Aufruf: "IsBuiltIn(typeof(Filestream)" soll er true liefern und bei "IsBuiltIn(typeof(Auto)" soll er false liefern.

Ist das checkbar, würde mich wie immer über Tipps freuen :)

Mfg

JP

xardias

Community-Fossil

Beiträge: 2 731

Wohnort: Santa Clara, CA

Beruf: Software Engineer

  • Private Nachricht senden

2

02.08.2015, 16:57

C#-Quelltext

1
typeof(Filestream).Namespace == "System"

Sollte funktionieren. Siehe: http://stackoverflow.com/questions/59325…-in-system-type

3

02.08.2015, 20:35

Ich danke dir :) es klappt wunderbar!!

aber sollte ich, um ganz sicher zu gehen, nicht doch eigentlich auf "mscorelib" prüfen?

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

4

02.08.2015, 20:57

Na ganz ausreichend ist es wohl nicht, besser wäre:

C#-Quelltext

1
typeof(Filestream).Namespace.StartsWith("System.") || typeof(Filestream).Namespace == "System"


Ansonsten, wenn du die dll prüfen möchtest, kannst du dir wie folgt den Namen der Assembly holen:

C#-Quelltext

1
typeof(FileStream).Assembly.GetName().Name

Sylence

Community-Fossil

Beiträge: 1 663

Beruf: Softwareentwickler

  • Private Nachricht senden

5

03.08.2015, 07:31

Den Namespace zu überprüfen ist nicht unbedingt 100% richtig. Beispiel:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
namespace System
{
   class MyCustomClass
   {
      ...
   }
}

...

IsBuiltIn( typeof( MyCustomClass ) ) // true


Wozu brauchst du diese Unterscheidung überhaupt?

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

6

03.08.2015, 10:36

Daher der Vorschlag zur Prüfung des assemblynamen. Ungeachtet dessen würde dich jeder für dieses vorgehen steinigen, Ähnlich wie eine Klasse im std namespace anzulegen.

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

7

03.08.2015, 10:38

Ich denk ich wiederhole die Frage nochmal, weil sie so wichtig ist: Wozu glaubst du das zu brauchen?

Sylence

Community-Fossil

Beiträge: 1 663

Beruf: Softwareentwickler

  • Private Nachricht senden

8

03.08.2015, 11:08

Ungeachtet dessen würde dich jeder für dieses vorgehen steinigen, Ähnlich wie eine Klasse im std namespace anzulegen.


Dann muss man aber auch darauf hoffen, dass der Programmierer gesteinigt wurde, bevor er seine Sachen pushen konnte ;)
Den Assemblynamen zu überprüfen (zb mit StartsWith( "System.") ) geht halt auch dann schief, wenn jemand vor dem steinigen auf die Idee kommt eine "System.MyCustomStuff.dll" zu erstellen.

Aber das nur am Rande. JungleProgger sollte jetzt erst mal sagen, warum er glaubt diese Unterscheidung überhaupt brauchen zu wollen.

9

03.08.2015, 11:58

Erstmal danke für die ganzen hilfreichen Antworten!

Und zu @dot:

Ich brauche dies, um die Bytelänge eines jeden Typs zu ermitteln:

hier der Code: Und dazu taucht noch ein Problem auf, bei der Überprüfung auf: type.IsBuiltInyType(// hier habe ich jetzt einen integer drin)
liefert er mi false?

Wieso, aber schaut selbst.

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 public static IEnumerable<byte[]> GetBytes(object current)
        {
            var type = current.GetType();

            if (current is IEnumerable && !(current is IDictionary))
            {
                var collection = (IEnumerable)current;

                foreach (var item in collection)
                {
                    return GetBytes(item);
                }
            }

            if (current is IDictionary)
            {
                var collection = (IDictionary)current;

                foreach (DictionaryEntry item in collection)
                {
                    return GetBytes(item.Value);
                }
            }

            if (type.IsBuiltInType(current)) // "IsBuiltInType" function does not work
            {
                _blocks.Add(ToBytes(current));
                return _blocks;
            }

            var fields = type.GetFields();

            foreach (var field in fields)
            {
                bool customType = !type.IsBuiltInType(field.GetValue(current));

                if (customType)
                    return GetBytes(field);

                var obj = field.GetValue(current);
                _memberBytes = ToBytes(obj);
                _blocks.Add(_memberBytes);
            }
            return _blocks;
        }


Ps: "ToBytes" ist eine private Funktion, die nur die übergebenen values in ein bytearray umwandelt

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

10

03.08.2015, 12:06

Au, das sieht richtig fies aus. Sowohl die Kompatibilität bei Änderungen in der Zukunft, als auch die Art und Weise an sich. Es gibt so viele Serialisierungsmöglichkeiten in C#, da sollte man wirklich nicht unbedingt selbst irgendwas merkwürdiges bauen. Soll es binär sein, schau Dir mal Protobuf an.

PS:
foreach (i) return i; tut ganz bestimmt nicht das, was Du Dir erhoffst.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Werbeanzeige