About interface class

[j3r3mi]

I have an abstract class named "Data Type" & an interface class name "Serialization"

I'm not sure how the interface class is being from G# point of view. It seems that "another" class is crerated if i implement the interfcae.

For example, i have a "NewClass" which inherits "Data Type" class AND implements "Serialization".

From the project, NewClass is created and its fine in the point.

BUT another interface class is created if i implemented the "Serialization".

I'm abit confused in the later. Shouldn't implementation works by just implementing the interface and not creating a new class??

[j3r3mi]

I saw a G#Interface class which has "Serialize" & "Deserialize" method. How can i implement this interface??

[Mattias_Ericsson]

Hi,

Well, interfaces in G# works, but it isn't the most user-friendly feature in G# I must admit that. However, it's the only way I could think of actully getting the interface concept (as C# defines it) to work. I really wish there could be a native interface support in LV classes, that would by sure make things easier.

This is how it works:

Since there isn't any native support for interfaces or multiple inheritance, we need to make a small trick. You have your class called "NewClass" and want to implement the already defined interface "Serialization". Then you might have another class called "NewClass2" (this class is not related in any way to "NewClass", this is the actual point using interfaces). "NewClass2" should also implement "Serialization". Since you might have a generic code somewhere that will called a method in the "Serialization" interface, lets call it "MethodA" and wants to loop all objects in an array that implement this interface. In LabVIEW this means that any class that implements the "Serialization" class, must be a LabVIEW native subclass, else LabVIEW won't compile. This is where the tricks comes in. By letting each class that would like to implement the interface class, just create a native class (this is the "extra" implementing class) that just "wraps" the reference of "NewClass" or "NewClass2". Each method of the "Serialization" is implemented in the "extra" implementing class and then just delegates the call to the "real" classes "NewClass" or "NewClass2". It is just a simple wrapper and deligate strategy used to implement the interface concept in G#. I don't think too many uses it, since it adds a few extra classes etc. Usually you just define an abstract base class, but then you can't write as generic code as you could with interfaces. When it is native in the language like in C# or Java it is a really useful feature of the language.

The "Serialization" & "Deserialiation" methods are just wrapper methods that will call serialization or deseralization of the objects implementing the interface. You could just use them as you would with an ordinary class. They need to exist, due to how G#Interface is implemented.

Please notice that there is an G#Interface example installed with the toolkit if you search for "G#" in "Find Examples" in LabVIEW.

Thanks,

Mattias

[j3r3mi]

Thanks for the reply!!

I have a another question with the class attribute. How can i initialize the class attribute when the class is created.

For example, I have a F32 class and a BOOL class.

I wanted them to have a class attrubte of "Type" which is an enum with elements "F32" & "BOOL"

Therefore i want the class attribute to be written when the class is created.

As for the interface, it seems that it will add far more memory if interface are implemented. I'll do with abstract class then.

I have another concern, as i'm using cRIO ni 9011 which has only 64mb of RAM and i don'y think it can run.

I already have developed an application with G# and deployed it on 9011 and it works fine. The code is only a Lite version of the framework i'm writing.

Currently i'm writing a full framework using G# which does hlaf dulplex communication (command-based) using RS485.

The framework stack has 4 layers. I'm afraid 9011 can't support this in terms of memory.

Well i already tried to only installed the necessary SW on it but the left memory is only 25%!!

Any guidelines for this?

My basic framework consist of

- ADT for U8, BOOL, F32 (will be expanding for more like fixed point , etc)

- Dictionaries for Linked List, Binary Tree, Stack, Queue, etc

[Mattias_Ericsson]

Hi,

Why don't you just initialize the class attribute with the type in the constructor? The class attributes are initialized and created when it is first referenced,e.g. when you do a "GetClassAttributes". One alternative you can use instead of using class attributes is to use the "GetClassName" method? It will return the name of your class for that particular object and since you are naming the classes"F32", "BOOL" etc. then it might work as well?

Sorry, don't have any good suggestions with the cRIO 9011 with G#. My advice would actually be, don't use G# if you have a really small amount of memory. G# is target to large systems and not small RT system. Maybe you can make just an ordinary LVclass instead? You could use the G#IDE to get all nice development features then.

Thanks,

Mattias

[j3r3mi]

I used G# because it has referenced objects. 🙂

[Mattias_Ericsson]

Good answer actually... Then I would suggest that you try to keep the number of classes to a minimum. Instead of making one class for each type (like you by sure would do in C#), there is a cost in LabVIEW when you make many classes. It consumes memory. One suggestion I usually do is when I would like to make entity classes (classes that represents a data entity) like your classes, then I usually try to make them a bit more generic. Instead of using one class for each differenent types, you can make only one representing a Variant instead. Just put a variant in your objects attribute and maybe a string called "type" etc. You could also name the object with the type as I mentioned earlier (make sure you are not using the default "Create or lookup existing" if naming the object with type,since you probably have many object of the same type). OpenG has a lot of nice variant utility feature that I like very much.

Just an idea!

Mattias