|
Vodstok wrote: I created a class called "Category" that is essentially built from some strings and an int, and i need to be able to dispose of it when i am done
There is nothing to dispose. You only need to use IDisposable if you are using unmanaged resources which you need to clean up, or you are using instances of classes that already implement IDisposable. Strings and ints fall in to neither category. The garbage collector will clean up the object when it is ready to do so.
|
|
|
|
|
ok, well that is a load off. This may be relevant to my problem: the object is being used as a static object. would that cause it to persist even though it has been "instantiated" with another identity? Essentially, the variable name is being reused on another page, but is returning all ofthe same information, even though it should be night and day different.
______________________
Mr Griffin, eleventy billion is not a number...
|
|
|
|
|
Vodstok wrote: the object is being used as a static object
Do you mean that the class is declared as static:
public static class MyClass
{
}
Vodstok wrote: would that cause it to persist even though it has been "instantiated" with another identity?
I don't understand what you mean by that. A static object, once created, will persist for the life of the application. You don't "instantiate" the object directly, the CLR decides when to do that. It is possible that a static class won't be "instantiated" (actually, for static classes, the term is "initialised") at all.
Vodstok wrote: Essentially, the variable name is being reused on another page, but is returning all ofthe same information, even though it should be night and day different.
If it is static then there is only ever the one "instance" (if you like).
|
|
|
|
|
sort of. the class isnt static, but the instance is:
public class Category
{
private static Category cat = null;
public static Category Instance(int id)
{
if(cat == null)
cat = new Category();
return cat;
}
Just an example snippet, but that is the gist of it
______________________
Mr Griffin, eleventy billion is not a number...
|
|
|
|
|
Vodstok wrote: the class isnt static, but the instance is
Okay - You are using the singleton pattern (which ultimately should produce the same effect as a static class - except you have a lot more work to do)
So, with that in mind, back to what you said earlier:
Vodstok wrote: ok, well that is a load off. This may be relevant to my problem: the object is being used as a static object. would that cause it to persist even though it has been "instantiated" with another identity? Essentially, the variable name is being reused on another page, but is returning all of the same information, even though it should be night and day different.
Assuming that the Instance method is the only thing that creates an Instance of the Category class (and that the constructor which isn't shown is private*) then it will get created once, and once only. The logic does not permit any other instance to be created.
It doesn't matter where in your application you access this, you will always get the same instance back.
* Which is normal for a singleton
|
|
|
|
|
For starters, you answered a question i have had for a long time, whihc was "what the hell is this method of creating objects called", so THANK YOU, it has been eating at me since i was introduced to it last year.
So let me see if i understand this properly. I use the method Category.Instance(1) to create an instance of an object, then go back and create Category.Instance(4), I now have 2 distinct objects that should not overlap in any way shape or form?
I may have another unrelated problem, but as long as Ikno where not to loolk, i will be better off 
Again, Thank you
______________________
Mr Griffin, eleventy billion is not a number...
|
|
|
|
|
Vodstok wrote: I use the method Category.Instance(1) to create an instance of an object, then go back and create Category.Instance(4), I now have 2 distinct objects that should not overlap in any way shape or form?
No, you still only have one object. I've annotated your code below:
public static Category Instance(int id)
{
if (cat == null)
cat = new Category();
return cat;
}
The logic prevents the creation of a new instance. cat is a static field, which means there will only be one regardless of how ever many instances of the class you create.
If you want to create new distinct objects through a method you may want to look at the Factory Pattern instead - the code above is part of the Singleton Pattern. (Are you familiar with design patterns? Or have you just muddled through and stumbled upon them without realising? - Both scenarios are good in different ways).
The Factory Pattern is a design pattern that permits a method (or class) to be responsible for the creation of objects. It can be a lot more flexible than using basic constructors.
The Singleton Patterns is a design pattern that constrains a class so that there will only ever be one instance of the class. In C# this is more commonly achieved by using a static class (i.e. the pattern is built in to the language). In other languages you can do this by controlling all instantiation through a single method (this is what you are doing in your code)
|
|
|
|
|
I found out what my problem was....
i have the block that starts with if(cat == null), and all of the logic assigning values to the various strings and ints in the object were contained in that block, so when i feed it a new id, it does nothing with it, exactly the way i coded it.....
______________________
Oh Hamburgers!
|
|
|
|
|
Vodstok wrote: I found out what my problem was....
This is what happens when I start writing a reply, get distracted, come back and finish it off... You find the answer by yourself. 
|
|
|
|
|
I appreciate you taking the time, and to answer the question in your other post, I have been muddling around in this pattern with no clear understanding of how it worked, but just that it made my life way easier.
I have not ever looked at desing patterns.
______________________
Oh Hamburgers!
|
|
|
|
|
Vodstok wrote: I have not ever looked at desing patterns.
You might want to look out for a book on the subject. There are books on design patterns in C#, or there are generic books that apply to any language. It would seem to me that you have figured out, or almost figured out, some on your own. Reading up on the subject will help get you a better understanding, and you can short circuit some of the trial and error of getting the thing right in the first place. It will also give you some good ideas of how to proceed in areas where perhaps you are still figuring things our, or have a solution that just does not feel right.
Once you have studied the basic patterns you can migrate on to some of the more interesting (in my opinion) patterns as given in Martin Fowler's book Patterns of Enterprise Application Architecture (IIRC). I wouldn't jump in to that book straight away though, it's a reference book for the most part, you'd need to understand the basics to get the best out of it.
Good luck.
|
|
|
|
|
Thank you again, it looks like i have some reading to do
______________________
Oh Hamburgers!
|
|
|
|
|
This is 50% curiousity, 50% because I might want to do this (so if this is a 'DON'T DO THIS EVER' type thing, by all means tell me) but I don't even know if its possible.
Say you had something like this:
class Book;
class CheckedOutBook : Book;
class Library
..void CheckOut(ref Book b, Person p);
Is it possible for CheckOut() to transform the book input into it so it is now a CheckedOutBook?
Obviously, you can return a new instance of CheckedOutBook, but I'm specifically talking about transforming the reference - my memories of C++ are that with pointers it should certainly be possible, but is it in C#?
To be clear I'm thinking of something like this:
Book b = new Book("Design Patterns");
(new Library()).CheckOut(b, new Person("Frank"));
Diagnostics.Assert(b is Book);
Diagnostics.Assert(b is CheckedOutBook);
|
|
|
|
|
Togakangaroo wrote: This is 50% curiousity, 50% because I might want to do this (so if this is a 'DON'T DO THIS EVER' type thing, by all means tell me) but I don't even know if its possible.
Code in the base class can cast itself to a derived class IF (AND ONLY IF) the object is actually an instance of the derived class in the first place.
HOWEVER, (and you're way ahead of me), this is a "DON'T DO THIS EVER" type of thing. The base class should have no knowledge of its derived classes. It is the responsibility of the derived class to know about its base.
If a base class uses information about derived classes then you lock the base class effectively. The base is no longer open to extension by other new derived classes at a later date. Any new derived class would potentially require changes in the base. This is bad.
Togakangaroo wrote: Is it possible for CheckOut() to transform the book input into it so it is now a CheckedOutBook?
This is a different question. CheckOut is a method on Library which is not in the same class heirarchy as Book and CheckedOutBook.
You have a ref Book b in the method signature, so I suppose you could REPLACE b with a CheckedOutBook but not transform the existing one. Also I consider using ref and out to be poor practice. In an OO system there are many better ways to accomplish the same thing. I see that there is no return value for the method so there really is no reason at all to be using ref as you can do that through the return value.
Also, the implication of CheckedOutBook is that you are assigning state (whether the book is checked out or not) to the class. State should be a property of the class, not the reason d'etre of the class.
I hope this helps.
|
|
|
|
|
Good point about not having a base class cast itself - As you pointed out, I guess in what I was saying CheckOut() would be what is doing the casting and really the only reason I would want to do this would be for fear of someone referring to the old variable later on in the scope. Obviously there are much better ways of preventing this. So let's move this entirely into the "I'm just curious" column.
|
|
|
|
|
I agree with Colin for the most part. It seems as though you are looking to use the class itself as a way to represent some information about the instance. Although as you mentioned this can work in C++, C# works very differently, and the type of an object really represents two things: first of all, the actual type of the instance, and secondly (in the case of base classes) a common interface (since subclassing is really just a way of implementing the base class's interface, from the perspective of someone using the object).
Anyhow, if you were to cast the instance of ref Book b to a CheckedOutBook inside CheckOut(), this would actually only apply to the local representation of b, and even though it's marked as ref, would not affect the object passed into it, namely because that object in the calling method already has an interpretation (type), and ref parameters allow an object to be changed, not how it is interpreted (i.e. its local apparent type).
As far as it being a "DON'T DO THIS EVER" thing, I think you'll quickly realize that it won't work, so it's not so much a warning as there's just no point in doing it.
Now that said, you might actually be able to do something like what you want by creating a new object of type CheckedOutBook, setting it as somehow equivalent to the passed-in Book, and then setting the ref b parameter to equal the new instance (since it is still a Book). The key is that you will have to create a new object, and the old one will still be floating around so long as it is used (elsewhere). However you appear to be aware of this scenario.
The short answer is no, you cannot "transform" a reference to be some type other than how it was created. Not in C#.
“Time and space can be a bitch.”
–Gushie, Quantum Leap
{o,o}.oO( Looking for a great RSS reader? Try FeedBeast! )
|)””’) Built with home-grown CodeProject components!
-”-”-
|
|
|
|
|
Hi there.
I want to add a button next to the Window Minimize button. (sth like this[^])
How can I do it ?
Thanks in advance .
|
|
|
|
|
Have a look here[^] - Vista compatible too!
DaveBTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)Expect everything to be hard and then enjoy the things that come easy. (code-frog)
|
|
|
|
|
Here is one article that I wrote on the subject: Add Transparent Menus and XP Titlebar Buttons to your application[^]
Regards,
Thomas Stockwell
Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning.
Visit my Blog
|
|
|
|
|
Is it possible to do this?
I can do it with a List<> but with an array it won't compile - 'Indentifier expected' where the open square bracket is.
Doesn't work:
public static implicit operator Range(DateTime[] dateTimeArray)
{
if (dateTimeArray.Length == 2)
return new Range(dateTimeArray[0], dateTimeArray[1]);
throw new ArgumentException("Invalid number of arguments");
}
Does work:
public static implicit operator Range (List<DateTime> dateTimeList)
{
if (dateTimeList.Count == 2)
return new Range(dateTimeList[0], dateTimeList[1]);
throw new ArgumentException("Invalid number of arguments");
}
DaveBTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)Expect everything to be hard and then enjoy the things that come easy. (code-frog)
|
|
|
|
|
Wierd - the damn thing started compiling and working just after posting - bizzare! The CP touch
DaveBTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)Expect everything to be hard and then enjoy the things that come easy. (code-frog)
|
|
|
|
|
Hmm, cool. Implicit operators are neat/weird.
“Time and space can be a bitch.”
–Gushie, Quantum Leap
{o,o}.oO( Looking for a great RSS reader? Try FeedBeast! )
|)””’) Built with home-grown CodeProject components!
-”-”-
|
|
|
|
|
The docs for Enum says (paraphrasing) "Enumerations have an underlying type used for storage, which by default is int"
So I have:
using System;
namespace Employee_Example1
{
public enum EmployeeType
{
FullTime = 0,
PartTime = 1,
Contract = 2,
Other = 3
}
public class Employee_Base
{
public int iEmpId = 0;
public int iEmployeeType = EmployeeType.FullTime;
public double dSalary = 0.00;
public string sLastName = "";
public string sFirstName = "";
public Employee_Base()
{
}
}
}
So why am I getting the error "Cannot implicitly convert type 'Employee_Example1.EmployeeType' to 'int'"
I have also tried "public enum EmployeeType : int", and it still won't compile. However, this works:
public int iEmployeeType = (int)EmployeeType.FullTime;
The question is, if the enum's underlying type is int, why do I need to cast?
Everything makes sense in someone's mind
|
|
|
|
|
There's unfortunately no implicit conversion from enum to int, although it should be possible without problems. I guess it's for the sake of type safety, C# is a bit restrictive here.
modified 12-Sep-18 21:01pm.
|
|
|
|
|
As Greeeg said above, there is no implicit conversion for a enum into an int. All conversions need to be done explicitly.
Just a question/though about your base class: why are you storing the enum as an int? I think for program clarity and maintainability, storing EmployeeType as the enum type would be the best way to go (and it will be more clear if your going to have an object out of the base).
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
