Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
10  11437 
My first thought is what a cool perversion of the language.
Hopefully James Fisher sees this - he was wanting to know how to
assign null to an int. Of course, things like this in a program I had
to work on would drive me crazy - it would have to VERY well
documented so that you didn't get yourself into trouble (not to
mention the work of overloading all the operators needed to make it
behave more like a real Int32)
-mike
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if
it were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
My first thought is what a cool perversion of the language.
Hopefully James Fisher sees this - he was wanting to know how to
assign null to an int. Of course, things like this in a program I had
to work on would drive me crazy - it would have to VERY well
documented so that you didn't get yourself into trouble (not to
mention the work of overloading all the operators needed to make it
behave more like a real Int32)
-mike
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if
it were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
Even better, I can use the System.DBNull class instead of the Dummy class.
DBNull.Value could be assigned, and compared to as well as null. It all
seems to be falling into place too easily... Again, wow.
"Michael Mayer" <mr*****@charter.net> wrote in message
news:#t**************@tk2msftngp13.phx.gbl... My first thought is what a cool perversion of the language.
Hopefully James Fisher sees this - he was wanting to know how to
assign null to an int. Of course, things like this in a program I had
to work on would drive me crazy - it would have to VERY well
documented so that you didn't get yourself into trouble (not to
mention the work of overloading all the operators needed to make it
behave more like a real Int32)
-mike
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om...
Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if
it were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
Even better, I can use the System.DBNull class instead of the Dummy class.
DBNull.Value could be assigned, and compared to as well as null. It all
seems to be falling into place too easily... Again, wow.
"Michael Mayer" <mr*****@charter.net> wrote in message
news:#t**************@tk2msftngp13.phx.gbl... My first thought is what a cool perversion of the language.
Hopefully James Fisher sees this - he was wanting to know how to
assign null to an int. Of course, things like this in a program I had
to work on would drive me crazy - it would have to VERY well
documented so that you didn't get yourself into trouble (not to
mention the work of overloading all the operators needed to make it
behave more like a real Int32)
-mike
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om...
Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if
it were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
I've seen these types, but I don't like having to call a method (or a
property whatever) to find out if it's defined. However I've been thinking
about this some more (its keeping me from sleeping...) and I've realized how
useless these types are in reality :(
static void Main(string[] args) {
tInt x = null;
Console.WriteLine( isNull(x) );
}
public static bool isNull( object x ) {
return x == null;
}
Go figure, this always return false for a struct because of boxing (sob).
Which brings me back to my original thoughts; In a world of virtual
machines and vast amounts of processing power, the added complexity of value
types is just not worth it.
Thanks for the reality check I guess. At least now I can sleep in peace!
"Jay B. Harlow [MVP - Outlook]" <Ja********@email.msn.com> wrote in message
news:ez**************@TK2MSFTNGP12.phx.gbl... John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
I've seen these types, but I don't like having to call a method (or a
property whatever) to find out if it's defined. However I've been thinking
about this some more (its keeping me from sleeping...) and I've realized how
useless these types are in reality :(
static void Main(string[] args) {
tInt x = null;
Console.WriteLine( isNull(x) );
}
public static bool isNull( object x ) {
return x == null;
}
Go figure, this always return false for a struct because of boxing (sob).
Which brings me back to my original thoughts; In a world of virtual
machines and vast amounts of processing power, the added complexity of value
types is just not worth it.
Thanks for the reality check I guess. At least now I can sleep in peace!
"Jay B. Harlow [MVP - Outlook]" <Ja********@email.msn.com> wrote in message
news:ez**************@TK2MSFTNGP12.phx.gbl... John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
John, I've realized how useless these types are in reality :(
Maybe not:
Consider:
public static bool isNull( object x ) {
if {x is INullable}
((INullable)x).IsNull;
else return x == null;
}
Basically if its a type that supports the INullable interface, ask the
object if its null, otherwise check to see if a null was passed.
The INullable interface is defined in the System.Data.SqlTypes namespace.
The interface is implemented by both the Sql data types & the Oracle data
types.
Hope this helps
Jay
"John" <fu******@hotmail.com> wrote in message
news:X9********************@news20.bellglobal.com. .. I've seen these types, but I don't like having to call a method (or a
property whatever) to find out if it's defined. However I've been
thinking about this some more (its keeping me from sleeping...) and I've realized
how useless these types are in reality :(
static void Main(string[] args) {
tInt x = null;
Console.WriteLine( isNull(x) );
}
public static bool isNull( object x ) {
return x == null;
}
Go figure, this always return false for a struct because of boxing (sob).
Which brings me back to my original thoughts; In a world of virtual
machines and vast amounts of processing power, the added complexity of
value types is just not worth it.
Thanks for the reality check I guess. At least now I can sleep in peace!
"Jay B. Harlow [MVP - Outlook]" <Ja********@email.msn.com> wrote in
message news:ez**************@TK2MSFTNGP12.phx.gbl... John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
John, I've realized how useless these types are in reality :(
Maybe not:
Consider:
public static bool isNull( object x ) {
if {x is INullable}
((INullable)x).IsNull;
else return x == null;
}
Basically if its a type that supports the INullable interface, ask the
object if its null, otherwise check to see if a null was passed.
The INullable interface is defined in the System.Data.SqlTypes namespace.
The interface is implemented by both the Sql data types & the Oracle data
types.
Hope this helps
Jay
"John" <fu******@hotmail.com> wrote in message
news:X9********************@news20.bellglobal.com. .. I've seen these types, but I don't like having to call a method (or a
property whatever) to find out if it's defined. However I've been
thinking about this some more (its keeping me from sleeping...) and I've realized
how useless these types are in reality :(
static void Main(string[] args) {
tInt x = null;
Console.WriteLine( isNull(x) );
}
public static bool isNull( object x ) {
return x == null;
}
Go figure, this always return false for a struct because of boxing (sob).
Which brings me back to my original thoughts; In a world of virtual
machines and vast amounts of processing power, the added complexity of
value types is just not worth it.
Thanks for the reality check I guess. At least now I can sleep in peace!
"Jay B. Harlow [MVP - Outlook]" <Ja********@email.msn.com> wrote in
message news:ez**************@TK2MSFTNGP12.phx.gbl... John,
Look at structures in System.Data.SqlTypes for similar implementation.
Jay
"John" <fu******@hotmail.com> wrote in message
news:f3**************************@posting.google.c om... Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {
private Dummy(){}
}
public struct tInt {
private Int32 val;
private Boolean def;
private tInt( Int32 pValue, Boolean pDefined ) {
this.val = pValue;
this.def = pDefined;
}
public static bool operator== (tInt lhs, Dummy rhs) {
return !lhs.def;
}
public static bool operator!= (tInt lhs, Dummy rhs) {
return lhs.def;
}
public static implicit operator tInt(Dummy pIn){
return new tInt( 0, false );
}
public override bool Equals( object pOther ) {
if ( pOther is tInt ) {
tInt wOther = (tInt)pOther;
if ( this.def && wOther.def) {
return this.val == wOther.val;
} else {
throw new Exception("not defined");
}
}
return false;
}
public override int GetHashCode() {
return base.GetHashCode();
}
}
/********************************************/
With these definitions I can now compare this struct to null as if it
were a reference type.
For example this works.
/********************************************/
tInt x = null;
if ( x == null ) {
Console.WriteLine( "x is undefined" );
}
/********************************************/
Wow.
I can now take this struct and make it behave just like an int that
also accepts null as a value.
What do you think? Cool or perverted?
This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics
by: ineedyourluvin1 |
last post by:
Hi, I would appreciate if someone could tell me what
I'm doing wrong ?
#include<iostream>
using namepace std ;
struct person{
char *firstname ;
int age ;
|
by: sathyashrayan |
last post by:
The standard confirms that the following initialization of a struct
struct node
{
---
---
}
struct node var = {NULL};
|
by: John |
last post by:
Ok. I'm not sure whether this is cool or perverted, I need second
opinion ;)
I define two classes as follows:
/********************************************/
public sealed class Dummy {...
|
by: Joanna Carter \(TeamB\) |
last post by:
Hi folks
I have a Generic Value Type and I want to detect when the internal value
changes.
///////////////////////////////
public delegate void ValueTypeValidationHandler<T>(T oldValue, T...
|
by: Ñ©ÔÆÓ¥ |
last post by:
Hi,all
I have a trouble about struct variable,the detail is :
I define a new struct which name ServiceProperty,then I declare a variable
like this:
ServiceProperty instService = null;
...
|
by: Brett |
last post by:
I have created a structure with five fields. I then create an array of this
type of structure and place the structure into an array element. Say index
one. I want to assign a value to field3 of...
|
by: skumar434 |
last post by:
Hi everybody,
I am faceing problem while assigning the memory dynamically to a array
of structures .
Suppose I have a structure
typedef struct hom_id{
int32_t nod_de;
int32_t hom_id;
|
by: sam_cit |
last post by:
Hi Everyone,
I tried the following program unit in Microsoft Visual c++ 6.0 and the
program caused unexpected behavior,
#include <stdio.h>
#include <string.h>
int main()
{
|
by: Seisouhen |
last post by:
Hi all,
I am using mmap to obtain some space(mapped anonymously) and am giving the address of the assigned space to a struct pointer. Then I want to access a member of the struct that the pointer...
|
by: Charles Arthur |
last post by:
How do i turn on java script on a villaon, callus and itel keypad mobile phone
|
by: emmanuelkatto |
last post by:
Hi All, I am Emmanuel katto from Uganda. I want to ask what challenges you've faced while migrating a website to cloud.
Please let me know.
Thanks!
Emmanuel
|
by: nemocccc |
last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
|
by: Hystou |
last post by:
There are some requirements for setting up RAID:
1. The motherboard and BIOS support RAID configuration.
2. The motherboard has 2 or more available SATA protocol SSD/HDD slots (including MSATA, M.2...
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...
|
by: Hystou |
last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can...
|
by: Oralloy |
last post by:
Hello folks,
I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>".
The problem is that using the GNU compilers,...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows...
|
by: tracyyun |
last post by:
Dear forum friends,
With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each...
| |
