Compare commits

..
Author SHA1 Message Date
Rodrigo Kumpera c9d9a10ff0 Merge remote-tracking branch 'origin/pr/1908' into HEAD 2015-07-02 14:04:45 -04:00
Alexander Kyte 6ea8bdec15 [runtime] Conversion of a printf to string append for performance 2015-07-01 16:34:20 -04:00
Alexander Kyte 0ab1aa2a78 [runtime] Avoid repeated method hashing in find_aot_module 2015-07-01 16:32:52 -04:00
Alex Rønne Petersen 198235db76 [profiler] Fix missing TYPE_JIT events for alloc/exception/monitor backtraces. 2015-06-05 22:10:07 +02:00
Alexis Christoforides 046a426065 Restore "Fix XAttribute.ToString method (Xamarin-29935)"
The patch is now accepted.
2015-06-05 15:33:58 -04:00
Atsushi Eno 19be22ca00 [xbuild] for resolving assemblies from pkg-config, prefer specified version
... even if SpecificVersion is false. There is no reason to prefer any
mismatching version when SpecificVersion=false.

That behavior caused monodevelop build failures because of incorrectly-
resolved gtk# packages. After this fix, this issue goes away.
https://github.com/mono/monodevelop/blob/2436ad1874694ec811871dacf9a659a79b5fad0d/README.md#known-problems
2015-06-05 14:19:03 -04:00
Miguel de Icaza 02adfce5cf [monop] Band-aid, cope with IKVM's Type.Namespace crashing on generic types
[monop] Add test suite for monop
2015-06-05 14:14:24 -04:00
Rodrigo Kumpera 8019f53849 Bump mono to 4.0.2 2015-06-05 14:14:21 -04:00
Zoltan Varga e967ed4868 [arm64] Increase the size of the thunk area to work around https://bugzilla.xamarin.com/show_bug.cgi?id=28747. 2015-06-05 14:02:47 -04:00
Zoltan Varga 2a0f19e0d2 [jit] Emulate OP_RREM if OP_FREM is emulated. Fixes #30698. 2015-06-03 15:31:48 -04:00
Alexander Kyte ef16e5a45c [runtime] Don't set flag to skip future initialization on half-baked classes 2015-06-03 12:13:20 +02:00
Zoltan Varga c68e6be205 [runtime] Fix the signature of native-func-aot wrappers. AOT the delegate invoke wrapper which is used to invoke it. Fixes #29970. 2015-06-02 19:05:26 -04:00
Sebastien Pouliot fad43d28b9 [corlib] Xamarin.Mac to continue default to the OS default codepage
XM 2.0 was the first version to ship the mobile (w/unified) and it used
the OS default codepage.

The previous, system mono, profile was already using the OS default
codepage so it make sense for XM to be consistent across profiles (
including the 4.5 subset)
2015-06-02 16:53:53 -04:00
Sebastien Pouliot e4510d8546 [corlib] Let XI and XM define their own default encoding [#29928]
605192528d used UTF8Unmarked for MONOTOUCH
and XAMMAC. However it's initialized differently (than the old UTF8) and
caused unit test regressions in System and System.Net.Http unit tests

This new logic moves the default encoding creation into the products
themselves.
2015-06-02 16:53:42 -04:00
Alexis Christoforides a3b2464acb Bump to include xamarin/bockbuild@0669caebbc 2015-06-02 16:02:38 -04:00
Alex Rønne Petersen 0bf88ca938 [profiler] Initialize threads in runtime initialization callback.
For the helper and writer thread to actually work, we need Mono's threading
subsystem to be initialized (so we can use TLS and hazard pointers). We now
wait with starting these threads until Mono gives us the go-ahead.

This means that a bit more data will be buffered up in the thread-local log
buffers during startup, but it shouldn't really matter in practice.
2015-06-02 15:50:15 -04:00
Zoltan Varga 348b0980cd [arm] Fix the handling of callee saved fp registers during unwinding, previously they were saved in an 32 bit array. Fixes #29726. 2015-06-02 15:28:12 -04:00
Zoltan Varga 80c4f56c1c [aot] Avoid duplicate plt symbols for plt entries for synchronized methods. Fixes #28961. 2015-06-02 15:27:14 -04:00
Sebastien Pouliot 955b2d61c9 [linker] Resolve AssemblyName[Reference] when sweeping [#29211]
The exact name (e.g. version) might differ between the original
AssemblyNameReference and the one being used (e.g. PCL).

To make sure we remove unused references we need to resolve
the AssemblyNameReference into AssemblyDefinition and then
continue the sweep based on the _new_ AssemblyNameReference.
2015-06-02 14:58:50 -04:00
Marcos Henrich d64e196394 Merge pull request #1758 from esdrubal/tzdroidfix
[corlib] Fixes DST without AdjustmentRules
2015-05-22 15:52:12 +01:00
Marek Safar ed1d3ec526 [corlib] BinaryReader with Unicode encoding needs to read bytes in a pair. Fixes #30171 2015-05-20 09:55:49 +02:00
Marek Safar 11b58305d0 [runtime] Add more 3.0 fx assemblies to remapping table. Fixes #29459 2015-05-15 15:55:26 -04:00
João Matos ef50e28e6c Merge pull request #1810 from directhex/mono-4.0.0-branch
Add missing Microsoft.Portable.VisualBasic_4.{0,5}.targets to EXTRA_DIST
2015-05-15 13:01:40 +01:00
Jo Shields de778fd998 Add missing Microsoft.Portable.VisualBasic_4.{0,5}.targets to EXTRA_DIST 2015-05-15 12:14:18 +01:00
Alexis Christoforides e308d07968 Bump to include mono/bockbuild@e94f64444d which reverts the nuget bump I mistakenly pushed to the branch. 2015-05-14 15:15:58 -07:00
Rodrigo Kumpera 766c45cacf Merge pull request #1807 from mono/revert-1787-Xamarin-29935
Revert "Fix XAttribute.ToString method (Xamarin-29935)"
2015-05-14 18:08:44 -04:00
Rodrigo Kumpera 00bd897cd6 Revert "Fix XAttribute.ToString method (Xamarin-29935)" 2015-05-14 18:07:21 -04:00
Atsushi Eno bee689faf9 Merge pull request #1787 from ermshiperete/Xamarin-29935
Fix XAttribute.ToString method (Xamarin-29935)
2015-05-15 02:54:40 +08:00
jaredpar 6d5afc17fc Improve Visual Basic build support
This fixes a couple of small issues with the Visual Basic build support:

- The VBC task now respects the $(NoStdLib) MSBuild option.
- The field @(ReferencePath) should be used for References in the VBC
target as it is for the CSC target.
- The CreateVisualBasicManifestResourceNames task is compiled and used
in the same manner as CreateCSharpManifestResourceNames hence it should
be loaded via UsingTask in the same manner as well.
- Include the VisualBasic Portable targets files.
2015-05-14 14:23:27 +02:00
Alan McGovern 888a961d27 Trigger a build 2015-05-14 08:20:25 +01:00
Zoltan Varga d17c251d93 [runtime] Fix the initialization of the pid array in ves_icall_System_Diagnostics_Process_GetProcesses_internal (). 2015-05-14 03:32:38 +02:00
Alexis Christoforides 83c226b78f Bump to include mono/bockbuild@78924fd36e. Fixes 29898 2015-05-13 10:31:23 -07:00
Marek Safar 79dbfbec17 [system.runtime.caching] Remove inappropropriate use of Marshal.SizeOf. Fixes #29667 2015-05-11 20:10:50 +02:00
Eberhard Beilharz 58acbf1239 Fix XAttribute.ToString method (Xamarin-29935)
This fix is more or less copied over from Microsoft's referencesource
implementation.

Change-Id: Icdb5979bd1b274afc5ee3a27f07db5ef64eb94aa
2015-05-11 15:13:04 +02:00
Eberhard Beilharz ec0d27cbc3 Unit test that demonstrates Xamarin-29935
Change-Id: I3510a2ccb897e0a0baf03af3a34bb74d6b700e03
2015-05-11 15:13:01 +02:00
Neale Ferguson d7f9ffaa25 Fix decimal comparison by using signed char comparison of signs; Fix size of jmp instruction sequence 2015-05-08 13:24:08 -04:00
Rolf Bjarne Kvinge f80248053d Add a monotouch_runtime corlib sources. 2015-05-06 17:52:29 -04:00
Zoltan Varga c06ccca9b4 [jit] Correctly disable seq points in wrappers on android. 2015-05-06 15:05:32 -04:00
Zoltan Varga 88674ce963 [sdb] Transition from step over to step into when control leaves managed code. Fixes #28557. 2015-05-06 15:03:37 -04:00
Mark Probst e280710722 [sgen] Check SP on thread suspend correctly. Fixes #29177. 2015-05-05 16:51:49 -04:00
Marcos Henrich f14352027e [corlib] Fixes DST without AdjustmentRules.
Fixes IsDaylightSavingTime returning false when
SupportsDaylightSavingTime was set to false because TimeZoneInfo was
create with no AdjustmentRules.

Now if TimeZoneInfo uses transitions SupportsDaylightSavingTime will be
set to true regardless of AdjustmentRules.
2015-05-04 14:30:50 +01:00
Sebastien Pouliot 5a0b19f1a1 [linker] Mark SecurityDeclarations [#28918]
Security declarations looks very similar to custom attributes - but
they are not (e.g. a different metadata table).

They need to be marked, just like other metadata, by the linker because
they can encode types that won't show up in the type (or assembly)
references.

Ignoring this can create an invalid binary (the kind that even Cecil
can't load back for further processing).
2015-05-01 13:45:09 +02:00
Zoltan Varga ed6b20ecc8 [jit] Increase some trampoline sizes. 2015-04-29 17:24:05 -04:00
Alex Rønne Petersen f5bd8428e3 [utils] Fix yet more visibility issues. 2015-04-29 18:03:55 +02:00
Alex Rønne Petersen 72e497f232 [mini] Fix visibility of mono_aot_get_method (). 2015-04-29 18:03:55 +02:00
Rolf Bjarne Kvinge 77adc2a461 [runtime] Don't call mach_port_deallocate on tasks we don't own.
Fixes random/strange hangs/crashes (many native API starts returning
out-of-memory errors when there is plenty of memory available, other
just hang inexplicably) when profiling.
2015-04-29 16:53:28 +01:00
Ludovic Henry d5acd37572 [runtime] Fix call to task_for_pid in proclib utils
task_for_pid requires special privileges on osx 10.5+ and ios, so it's better to avoid calling it.
2015-04-29 16:53:19 +01:00
João Matos e5678fa983 [aot] Improve error checking when setting up class vtable.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=28816.
2015-04-29 16:35:11 +01:00
Zoltan Varga 9476d562d9 [jit] Use the same dwarf<->hw register mapping on x86 for both LLVM and jitted code, the one used by LLVM is the official version.
Cherry-pick of https://github.com/mono/mono/commit/2cab68d28c574320f6927b6677b4e3ea213b2e20.
2015-04-29 16:22:10 +01:00
Alex Rønne Petersen c110da5dc6 [mini] Expose mono_aot_get_method () as an API-unstable function.
This will be used by the profiler.
2015-04-29 16:34:19 +02:00
Alex Rønne Petersen 44ba74f134 [mini] Expose an API-unstable mono_get_jit_info_from_method () function.
This will be used by the profiler.

Conflicts:

	mono/mini/mini-runtime.c
2015-04-29 16:34:04 +02:00
Alex Rønne Petersen 0424c0e425 [profiler] Disable perf events by default.
As it turns out, `perf` support crashes/hangs on a lot of Linux
kernels in the wild, and produces no output on some Android devices.
So, given that using a signal + helper thread is more reliable, use
it by default and make `perf` support optional.

The configure flag is now `--enable-perf-events`.
2015-04-29 10:45:01 +02:00
Alex Rønne Petersen 145bf1a485 [profiler] Avoid a slow path in mono_jit_info_table_find (). 2015-04-29 10:44:56 +02:00
Alex Rønne Petersen 5b658b5c72 [profiler] Really fix looking up JIT info for AOT'd methods.
mono_aot_get_method () will not necessarily put methods into the
MonoDomain::jit_code_hash table. But it does return an IP that we
can use to look up the JIT info with mono_jit_info_table_find ().
2015-04-29 10:44:48 +02:00
Alex Rønne Petersen f81d1dba42 [profiler] Fix finding methods in other domains than the current one.
In certain cross-domain scenarios, the method we're executing
is not necessarily emitted in the current domain. So we need
to scan all domains for it.
2015-04-29 10:44:39 +02:00
Alex Rønne Petersen e01c79dffd [profiler] Redesign buffer flushing and method reporting.
The main goal of this change is to ensure that all methods have a `TYPE_JIT`
event emitted in the stream before they are referenced in other events. Before
this change, `TYPE_JIT` events could arrive out of order or not be emitted at
all because of generic sharing.

We now use a separate thread for writing log buffers to the output file.
Whenever a method is referenced in a TLS log buffer, we add it to a TLS list of
methods. When we ship the TLS log buffer off to the writer thread, we also send
the TLS list of methods. The writer thread first goes over all the methods and,
if some of them haven't had a `TYPE_JIT` event emitted yet, emits them to a
temporary buffer which is flushed just before flushing the main log buffer.

This approach ensures that `TYPE_JIT` events will *always* come before the
events that reference them.

Bookkeeping of which methods have been emitted to the output stream is done in
a global, concurrent hash table. Before a thread adds a method to its TLS list
of methods, it checks if the method is in the hash table. If it is, we know
that the method has already been emitted to the output stream, so it isn't
added to the list. The writer thread is the only thread that updates the hash
table (which happens when it flushes the temporary method buffer). So,
eventually, all TLS method lists will end up being empty because all methods
have been emitted to the output stream.
2015-04-29 10:44:31 +02:00
Zoltan Varga 373d684397 Fix the mobile build. 2015-04-28 15:58:47 -04:00
Zoltan Varga 735f5b3ee8 [runtime] Fix the non-msvc build. 2015-04-27 16:08:47 -04:00
Zoltan Varga feb16e4022 [jit] Disable deadce in the liveness2 pass as well when compiling for sdb. Fixes #28847. 2015-04-27 15:20:01 -04:00
Alex Rønne Petersen 436c5d2e57 [mini] Fix intrinsic signature checks to take into account the 'this' parameter. 2015-04-27 15:11:40 -04:00
Zoltan Varga d0620f1ab5 [runtime] Fix freeing invalid memory in CreateProcess () if the executable was not found. Fixes #28209. 2015-04-27 15:00:45 -04:00
Alexis Christoforides 3a6e855647 [DataContractJsonSerializer] Allow abstract base classes in lists. Fixes #26998
Abstract classes can still have subclasses with KnownType attributes, which are allowed in deserialization.

This used to work as the '__type' hint  was always honored no matter the type, and broke with https://github.com/mono/mono/commit/71e152accc727089faffa6b4fd6bf58cb62636cf which removed that behavior.
2015-04-27 12:17:31 -04:00
Marek Safar 5521f11004 [corlib] First specific culture returned by enumerator was not fully initialized. Fixes #29039 2015-04-27 16:43:41 +02:00
Marek Safar 1513f8f827 Merge pull request #1727 from esdrubal/mono-4.0.0-branch
[System.Xml] Fixed DateTime parsing of Xml strings
2015-04-27 16:35:26 +02:00
Miguel de Icaza 7975f5090d Update version 2015-04-26 09:00:31 -04:00
Marek Safar 1aa57ef746 [corlib] Add DefaultDllImportSearchPathsAttribute 2015-04-25 08:53:19 -04:00
Alexis Christoforides fd35b80bef Bump to bring in xamarin/bockbuild@257a1a8920 2015-04-22 15:20:53 -04:00
Marcos Henrich 71385a445f [System.Xml] Fixed DateTime parsing of Xml strings
System.Xml was failing to parse DateTime serializations such as
"2000-02-29T23:59:59+13:60".
This is caused by using .NET DateTime and still having the old
System.Xml in branch 4.0
This logic is implemented in .NET by XsdDateTime.
Added fallbacks to .NET XsdDateTime (renamed to XsdDateTime2) when our
parser fails.

The fix is specific to mono 4.0. As in mono master we are already using
.NET System.Xml.
2015-04-22 13:27:32 +01:00
Alexis Christoforides c8db1b0fbc Bump to bring in xamarin/bockbuild@42570d260b 2015-04-16 12:52:12 -04:00
Rodrigo Kumpera d136b7923f Commit marker for the gtk rendering fix. 2015-04-13 11:42:16 -04:00
João Matos ba35e6882f Merge pull request #1697 from directhex/mono-4.0.0-branch
[RPM] Fix MONO_PATH in RPM dependency generators
2015-04-09 13:22:29 +01:00
Jo Shields 0dfb848cde [RPM] Fix MONO_PATH in RPM dependency generators
Otherwise, RPMs don't have any dependency information
2015-04-09 13:19:15 +01:00
Zoltan Varga f42a83b1b4 [runtime] Allocate more space to thunks in dynamic methods. Fixes #28747. 2015-04-07 17:15:21 -04:00
Alexander Köplinger 38e08858e6 Fix incorrectly resolved merge conflict
aot-compiler was incorrectly removed from net_4_5_SUBDIRS in ccc2e36bc5, it should still be there in mono-4.0.0-branch (it was moved to  net_4_5_PARALLEL_SUBDIRS in 3ceb869495 later on).
2015-04-07 14:36:12 +02:00
Alexander Köplinger ccc2e36bc5 Integrate binary reference assemblies for v2.0/3.5 into the build system
Rename the net_4_0 profile which is already only used to trigger copying of reference assemblies
to binary_reference_assemblies and include the 2.0/3.5 files there. This should make it easier
to add more profiles in the future and doesn't clutter the build system as much as making separate
net_2_0 and net_3_5 profiles that do the same.

Conflicts:
	mcs/class/Makefile
2015-04-06 18:27:27 -04:00
Rodrigo Kumpera fe1279932f Update the reference assemblies we ship in mono. 2015-04-06 12:52:37 -04:00
Marcos Henrich 9236ac41e9 [corlib] TimeZoneInfo.TryAddTicks is now private. 2015-04-04 15:22:07 +01:00
Marek Safar 4639c99a48 [mcs] Mutate nested storey initialization only when needed. Fixes #28211 2015-04-03 15:55:07 +02:00
Marcos Henrich 7fc9ff987a [corlib] Refactored TimeZoneInfo DateTime overflow checks.
Added more overflow checks.
Fixed some overflow checks.
2015-04-03 10:27:53 +01:00
Marcos Henrich 989c0ff6aa [corlib] Fixed ParseTZBuffer with DST periods longer than a year.
AdjustmentRule specifies a DST period that starts and ends within a year.
When we have a DST period longer than a year, the generated AdjustmentRule may not be usable.
Thus we fallback to the transitions.
Fixes #24086.
2015-04-03 10:27:52 +01:00
Marcos Henrich 4420113b52 [corlib] Removed referencesource duplicated code. 2015-04-03 10:27:51 +01:00
Marcos Henrich f7c051a73c [corlib] Renamed GetUtcOffset to GetUtcOffsetHelper.
The new name is to avoid using the helper method instead of GetUtcOffset.
2015-04-03 10:27:50 +01:00
Marcos Henrich c555aee959 [corlib] Changed TimeZoneInfo methods to use GetUtcOffset.
In some cases rules are not available so we use GetUtcOffset instead of GetApplicableRule.
2015-04-03 10:27:48 +01:00
Sebastien Pouliot f26999f403 [linker] Ensure updated Scope for exported types (e.g. unlinked PCL facade assemblies in a Nuget) [#28617] 2015-04-02 16:46:11 -04:00
Sebastien Pouliot 125e4f4705 [tools] Fix mono-cil-strip to return non-zero on failure [#28617] 2015-04-02 16:46:01 -04:00
Marek Safar 8d291f789a [mcs] Handle null operator inside parenthesis expression. Fixes #28172 2015-04-02 15:24:33 +02:00
Zoltan Varga f70e175f52 Fix the build. 2015-04-01 10:53:48 -04:00
Zoltan Varga cd906692af Revert "Fix the build."
This reverts commit 21d849bd5b.

Revert this as it picked up unrelated changes.
2015-04-01 10:52:35 -04:00
Marek Safar 1830c45f5e [system.net.http] Use correct separator for headers tostring 2015-04-01 10:01:47 +02:00
Sebastien Pouliot 3a1c4b6e41 [tests] ManualResetEventSlim.SpinCount depends on the number of CPU/cores and we can't assume everything as multiple CPU/cores [#28611] 2015-03-31 21:30:48 -04:00
Zoltan Varga bce084ad29 [runtime] Add more caches to mono_marshal_get_native_wrapper () to avoid mixing wrappers with/without exception checks. 2015-03-31 18:33:13 -04:00
Zoltan Varga 21d849bd5b Fix the build. 2015-03-27 12:14:31 -04:00
Zoltan Varga ce30aaaa01 [runtime] Synchronize the overflow checks between mono_string_new_size () and mono_gc_alloc_string (). 2015-03-27 06:38:14 -04:00
Zoltan Varga 5c1a143121 [jit] Avoid emitting seq points in inlined methods. 2015-03-27 06:37:55 -04:00
Marek Safar f99b5b2825 [mcs] Reset flowanalysis finally scope per parameters block. Fixes #28196 2015-03-27 07:36:34 +01:00
Zoltan Varga ce674ebde7 [io-layer] Fix the freeing of MonoProcess structures. Fixes #28209. 2015-03-26 20:50:36 -04:00
Marek Safar 87c62a19b2 [system.net.http] Parse range values using long range. Fixes #26109 2015-03-26 23:47:04 +01:00
Marek Safar d2a79f98fb [mcs] The left-hand side of an assignment cannot contain a null propagating operator. Fixes #28435 2015-03-26 22:52:38 +01:00
Vincent Povirk 051999d6f0 Rename decimal functions to not conflict with win32 versions. 2015-03-26 21:01:45 +01:00
Martin Baulig 4e6e2a89fe [System]: Fix the AllowWriteStreamBuffering check. Bugs #26640 and #26936.
Added new tests for this to the web-tests:
https://github.com/xamarin/web-tests/commit/e7b5ac42897e629e9e4107cf6f9ae9e0a9fef45a

and re-enabled this one, which regressed:
https://github.com/xamarin/web-tests/commit/046da02c631c8799c7ab5025cd3b685f4a3e66f6

(cherry picked from commit 6808e6a5e6)
2015-03-26 16:13:39 +01:00
Marek Safar 291931ebea [mcs] Report abstract member hiding only for members which one can override. Fixes #28213 2015-03-26 10:06:52 +01:00
Marek Safar 57df2b7bc3 [mcs] Resize identifier buffer in all cases. Fixes #28292 2015-03-25 17:19:04 +01:00
Marek Safar 4fb3a99b5f [mcs] Fix parsing of interpolated strings inside conditional expression. Fixes #28293 2015-03-25 16:37:22 +01:00
Marek Safar b4eb72ca7d [mcs] Allow built-in types to have partial declaration 2015-03-25 15:13:25 +01:00
Zoltan Varga c61bcc925d [runtime] Avoid returning null from Marshal.AllocCoTaskMem () if size is 0. Fixes #28383. 2015-03-25 01:31:33 -04:00
Alex Rønne Petersen b4d6290008 [profiler] Make perf syscall work on ARM64. 2015-03-25 02:43:34 +01:00
Alex Rønne Petersen 9e5820094b [profiler] Clean up some unused declarations. 2015-03-25 02:43:29 +01:00
Alex Rønne Petersen 86ee34858d [profiler] Don't build the profiler on Windows. 2015-03-25 02:43:17 +01:00
Alex Rønne Petersen b0a10b2f73 [configure] Add a --disable-perf-events flag to disable perf on Linux. 2015-03-25 02:43:07 +01:00
Alex Soto 84a1764a57 [MonoDataSqlite] Add test for Xamarin.iOS specific bug 27864
src: https://bugzilla.xamarin.com/show_bug.cgi?id=27864

As of iOS 8.2 Apple updated Sqlite and broke queries that used to work
pre iOS 8.2 like the select command in this test, The pruppose of this
test is to know when apple fixes this. Expected test behaivour is as follows.

* If iOS 8.2+ Test will pass as long as apple does not fix the bug
* If iOS < 8.2 Test will pass as it does work as expected
* If iOS 8.2+ and apple fixed bug 27864 test will fail and we will need to
  remove the fail check on lines 105 and 106
2015-03-24 17:34:19 -06:00
Zoltan Varga a0a93c4263 Revert "[io-layer] Fix the freeing of MonoProcess structures. Fixes #28209."
This reverts commit 9e351577c2.

Revert this until it is fixed.
2015-03-24 17:35:54 -04:00
Zoltan Varga e25c686499 Revert "[runtime] Fix an uninitialized memory error added by eaf200b37bd8ba29d59fc7054f8409e9b76b5697."
This reverts commit 2335cca8fd.

Revert this until it is fixed.
2015-03-24 17:35:40 -04:00
Zoltan Varga d2f18038ba Revert "[runtime] Fix another regression caused by eaf200b37bd8ba29d59fc7054f8409e9b76b5697."
This reverts commit 5c55cf4b06.

Revert this until it is fixed.
2015-03-24 17:35:20 -04:00
Zoltan Varga 5c55cf4b06 [runtime] Fix another regression caused by eaf200b37b. 2015-03-24 16:51:53 -04:00
Marcos Henrich ec5f493016 [System] Fixed RemoveConnectionGroup concurrent issue.
CloseConnectionGroup can concurrently call RemoveConnectionGroup and remove a group that has added to removeList.
We now check that the group still exists before removing it.
Fixes #19823.
2015-03-24 19:19:09 +00:00
Zoltan Varga 2335cca8fd [runtime] Fix an uninitialized memory error added by eaf200b37b. 2015-03-24 14:56:31 -04:00
Zoltan Varga 9e351577c2 [io-layer] Fix the freeing of MonoProcess structures. Fixes #28209. 2015-03-24 12:37:01 -04:00
Sebastien Pouliot b7bcd23071 [tests] Tweak MemoryMappedFile test case that fails on iOS/ARM64 [#27667]
Filled with Apple. From bug report:

The problem appears to be caused by a bug in mmap on the arm64 ios.

In this test, we request a page and mmap returns successfully, but when trying
to access the mapped memory, the program crashes after the 4097th byte, meaning
that it only maps us 4kb(???). It should be mentioned that on arm64 ios the
page size is 16kb.
2015-03-24 10:47:32 -04:00
Sebastien Pouliot 798a777153 Revert "Fix mmap past file end on arm64 ios."
This reverts commit 70f5971e04.
2015-03-24 10:17:08 -04:00
Alex Rønne Petersen c52336f439 [arm] Also fix OP_ATOMIC_STORE_R4. 2015-03-24 04:26:04 +01:00
Sebastien Pouliot e3dc17469e [tests] Tweak DateTime.AddMillisecondsOutOfRangeException* tests to work on ARM [#28311] 2015-03-23 18:09:14 -04:00
Marek Safar 26d10e6572 Bump reference sources for bug #28331 2015-03-23 20:12:40 +01:00
Zoltan Varga 89a9c7646e [arm] Fix OP_ATOMIC_LOAD_R4. 2015-03-23 14:25:45 -04:00
Sebastien Pouliot b1c6715167 [tests] Some of the new decimal tests (ported from MS tests) do not work on every culture, this set one that works for them 2015-03-20 15:26:39 -04:00
Zoltan Varga f1258f8548 [runtime] Disable the locking of archives in libtool, it was a workaround around an old darwin bug which got fixed years ago: http://lists.gnu.org/archive/html/bug-libtool/2009-05/msg00062.html. 2015-03-20 00:18:06 -04:00
Zoltan Varga a4372a69fb [aot] Fix support for direct icalls in llvm mode. 2015-03-19 23:26:41 -04:00
Zoltan Varga d474800f1a [jit] Use unique castclass caches in all cases. Fixes #27787. 2015-03-19 22:46:25 -04:00
Zoltan Varga a59c479a68 [runtime] Fix the isinst_with_cache wrapper on 64 bit platforms. 2015-03-19 22:46:17 -04:00
Zoltan Varga ce8f657da1 [io-layer] Avoid closing std file descriptors on shutdown. Fixes #28098. 2015-03-19 17:36:36 -04:00
Zoltan Varga 1605a60754 Fix the build. 2015-03-17 17:44:06 -04:00
Zoltan Varga 67a5a11bd3 [jit] Avoid disabling direct calls to icalls on arm64+llvm. 2015-03-17 17:38:51 -04:00
Zoltan Varga 00232c8704 [jit] Add exception checks after direct calls to icalls by inlining the wrapper. 2015-03-17 17:38:22 -04:00
Zoltan Varga 44a0663032 [jit] Disable direct icalls for now to fix the build. 2015-03-17 17:38:12 -04:00
Zoltan Varga 93cae9f52b [jit] Add support for directly calling normal icalls. Enable it for a few perf-sensitive classes like Math. 2015-03-17 17:37:31 -04:00
Zoltan Varga 0078c40250 [aot] Enable direct calls to icalls in aot mode, disable them when the 'direct-calls' aot option is used. 2015-03-17 17:33:41 -04:00
Zoltan Varga 18d408f00d [jit] Disable direct calls to icalls when using llvm, llvm can't handle direct calls to 64 bit addresses (tests/jit-float.exe fails). 2015-03-17 17:28:54 -04:00
Zoltan Varga 9578437645 [jit] Make the opcode emulation jit icalls callable without a wrapper in some cases. 2015-03-17 17:26:18 -04:00
Zoltan Varga df3eb65bb7 [runtime] Use mono_set_pending_exception () in some places in icalls. Avoid using it for throwing exceptions returned by mono_thread_execute_interruption (), since that seems to cause problems. 2015-03-17 17:25:15 -04:00
Zoltan Varga 82b07416d5 [runtime] Mark mono_set_pending_exception () as a cold function, so calling code is generated out-of-line. 2015-03-17 17:25:02 -04:00
Zoltan Varga 886b00dc1c [jit] Use mono_set_pending_exception () instead of throwing exceptions in JIT icalls. 2015-03-17 17:24:56 -04:00
Zoltan Varga 990c40cd4e [jit] Make mono_thread_interruption_checkpoint () return the exception which needs to be thrown and throw it from the managed method/wrapper which called it. 2015-03-17 17:24:27 -04:00
Vlad Brezae 1b875c9b15 [x86] Handle stack pop done by native stdcalls.
The problem was caused with the introduction of the pushless backend. We have to compensate for the arguments being popped by native stdcall callees, to keep param_area from shrinking. Fixes #27597
2015-03-17 04:53:59 -04:00
Zoltan Varga e4c026208c [io-layer] Avoid the usage of atexit (), clean up handles normally. 2015-03-16 16:26:37 -04:00
Marcos Henrich 52ddcb28c3 [runtime] Fixed Process.GetProcesses ().
Process.GetProcesses () was not returning any processes.
2015-03-16 12:56:00 +00:00
Zoltan Varga 565c18bf2f Fix the build. 2015-03-14 15:13:08 -04:00
Zoltan Varga c961e6ed4b Fix the aot compiler. 2015-03-14 05:02:19 -04:00
João Matos d5b9350783 [aot] Wrap the commands we pass to Windows's system() in double quotes.
We need an extra set of quotes around the whole command to properly handle commands
with spaces since internally the command is called through "cmd /c.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=27899.
2015-03-13 17:15:12 +00:00
João Matos 3f23cdd9a5 [aot] Escape the command executables with quotes to deal properly with spaces in paths. 2015-03-13 17:15:10 +00:00
João Matos b4921c741c [aot] Ensure the LLVM tools path ends with a directory separator appropriate to the system. 2015-03-13 17:15:08 +00:00
Rolf Bjarne Kvinge eee6839126 [mono-api-html] Render generic parameter constraints.
Makes changed constraints show up in diffs.
2015-03-13 16:44:20 +01:00
Zoltan Varga 3b18a06f63 [jit] Throw the proper exception on integer overflow from div/rem if MONO_ARCH_NEED_DIV_CHECK is defined. 2015-03-12 18:28:04 -04:00
João Matos 08678f18e7 [eglib] Fixed file being created without read/write permission on Windows.
This bug manifested itself as files being written to disk with 0 bytes.

Fixes the AOT compiler on Windows not working properly.

https://bugzilla.xamarin.com/show_bug.cgi?id=27900
2015-03-12 16:41:37 +00:00
Marcos Henrich d51afc4c5b [corlib] TimeZoneInfo.TryGetTransitionOffset overflow checks. 2015-03-12 13:23:03 +00:00
Marcos Henrich bc7b4e330a [corlib] Fixed DateTime overflow check in TimeZoneInfo. 2015-03-12 12:46:17 +00:00
Zoltan Varga 9f0f929a97 [jit] Enable the gsharedvt testcase which now works. 2015-03-11 18:48:39 -04:00
Rodrigo Kumpera 165a47d044 Merge pull request #1625 from BrzVlad/fix-ios-mmap
Fix mmap past file end on arm64 ios.
2015-03-11 17:14:55 -05:00
Vlad Brezae 70f5971e04 Fix mmap past file end on arm64 ios.
On arm64, where page size is 16k, if trying to map after the file end mmap doesn't map us the full page but only 4kb. This bug is present on iOS 8.2. As a workaround, we forcefully extend the file to the desired size to make sure than we can map the full page.

https://bugzilla.xamarin.com/show_bug.cgi?id=27667
2015-03-11 14:01:43 -07:00
Marek Safar fac9fc87e6 [system] Fixes InvalidCastException in OpenReadAsyncCallback 2015-03-11 17:28:59 +01:00
Rodrigo Kumpera 5554b6ad11 [io-layer] When checking if a file is a program check both read and execute permissions. Fixes #27565
The original behavior of only checking for read permission broke sudo on OSX which only have the execute permission set.
2015-03-11 12:28:51 -04:00
Jo Shields 625f62c167 [msvc] Change target MSVC release from v120 to v120_xp
They're basically the same thing, but v120 has DX10+ capabilities and v120_xp
is DX9 only. Since we're not building against DirectX, the difference is
purely academic - but changing the value to v120_xp means MSVC binaries run
on XP+, not Vista+

(cherry picked from commit 577482e336)
2015-03-11 15:25:16 +00:00
Jo Shields d3aedd8189 [msvc] Refresh .def files
(cherry picked from commit 1d33de4a70)
2015-03-11 12:06:46 +00:00
Jo Shields 1bd3b8aca0 Bump winconfig.h to 4.0.0 2015-03-11 10:13:09 +00:00
Jo Shields 39dbbe2d65 Use MSVC2013 for *all* mono.sln dependants
(cherry picked from commit c127ea46a3)
2015-03-11 10:00:48 +00:00
Jo Shields 7f27bd72df Add _WIN32_WINNT to Release definition, not just Debug
(cherry picked from commit 21bc7fa948bee919644a733ca1355366c69926fd)
2015-03-11 09:49:15 +00:00
João Matos f31b86c340 [runtime] Upgraded Jay MSVC project to VS 2013.
(cherry picked from commit b528a79db5)
2015-03-11 09:37:25 +00:00
João Matos bc98119172 [runtime] Fixed the MSVC build.
Even though this seems like it's just moving the files around in the project, for some reason it makes a difference to VS.

(cherry picked from commit 220afd9d49)
2015-03-11 09:30:01 +00:00
Zoltan Varga 1aba894227 Fix the build. 2015-03-10 18:26:51 -04:00
Zoltan Varga 419f2abbd9 Fix some bugs in 92ca06aa7d. Fixes #26989. 2015-03-10 17:54:26 -04:00
Zoltan Varga ab869b5517 [jit] Fix the handling of byref locals in mono_allocate_stack_slots2 (). 2015-03-10 17:52:42 -04:00
Mark Probst c00db28a9b [tests] Test case for #27147. 2015-03-10 14:44:52 -07:00
Mark Probst a69610255d [sgen] Fix a bug in 64 bit LOS cardtable scanning. Fixes #27147. 2015-03-10 14:44:50 -07:00
Alexander Köplinger 397fb0c548 [corlib] Fix timezone dependent DateTimeOffset test
Instead of trying to recreate the date with the current timezone, we should make the date assume UTC and compare against that.
2015-03-09 21:59:43 -04:00
João Matos 73d7873d31 [runtime] Fixed Windows mono_threads_core_get_stack_bounds to work with cross-compiled targets. 2015-03-09 14:22:16 +00:00
João Matos 66c1b9c77c Enable x86 cross compilation on Windows. 2015-03-06 18:15:12 +00:00
João Matos 922f5662ed Do not try to use the native GCC linker when targeting Android from Windows. 2015-03-06 17:43:06 +00:00
João Matos 59c0207c87 Fixed Windows system commands calls with non-ASCII paths.
This is a bit of an hack but it works for now... ideally we should be processing the Unicode command line flags passed by the CRT at startup instead of trying to convert the MBCS string to a wide string.
2015-03-06 17:43:04 +00:00
Sebastien Pouliot e80398b23f Remove the EXPORT ciphers and related code path
That was still useful in 2003/2004 but the technical and legal landscape
    changed a lot since then. Removing the old, limited key size, cipher
    suites also allow removed additional parts of the code that deals with
    them.
2015-03-06 10:37:57 -05:00
Sebastien Pouliot 4c54e08936 Remove the client-side SSLv2 fallback.
There's almost no SSLv3 web site left so a v2 fallback is only extra
    code we do not need to carry forward.
2015-03-06 10:37:55 -05:00
Sebastien Pouliot 5c2a3c25fd TLS protocol: add handshake state validation 2015-03-06 10:37:53 -05:00
Rodrigo Kumpera 53d221e810 [loader] If probing for a pinvoke fails, log the error mono_dl_symbol gives us.
We used to swallow the error, which is unhelpful.

The reason for that might be because we probe multiple names before giving up but
even then, it's ok log all attempts. It will make troubleshooting easy, even if we
have to go through a lot more log entries.
2015-03-05 15:22:03 -05:00
Zoltan Varga ea43208df6 [sdb] Avoid asserts on darwin when the thread deregistration code is ran from a pthread dtor. Fixes #27697. 2015-03-05 15:03:54 -05:00
Sebastien Pouliot 81f43a2487 [tests] IPInterfaceProperties DNS address does not currently work on iOS devices (since it read /etc/resolve.conf). Ignore it for XI until #27707 is fixed 2015-03-05 14:04:09 -05:00
Miguel de Icaza 89a08ecc33 [System.ServiceModel.Web/WebMessageFormatter] Fix OperationContracts with void returns
WebMessageFormatter crashes when the OperationContracts had a void return type.

Fixes #20764, patch from <[email protected]>
2015-03-05 11:34:39 -05:00
Miguel de Icaza 9aae4ade12 [SslClientStream] Prevent crashes when a connection is closed
When a socket has been closed as part of the negotiation, the
SendAlert method would crash when trying to reuse the socket.

Add try/catch around this to prevent this.

Fixes #19334
2015-03-05 11:33:55 -05:00
João Matos 51d34c61fd Support multiple options when processing the AOT flag "ld-flags". 2015-03-03 16:29:41 +00:00
Zoltan Varga 1050938254 [aot] Fix thumb support with separate llvm modules. 2015-03-02 22:38:38 -05:00
Zoltan Varga ab5d6b3b9f [arm] Fix support for backward branches in mono_arm_get_thumb_plt_entry (). 2015-03-02 22:38:33 -05:00
Marek Safar b6438ca27b [mcs] Handle string constants inside interpolated string expression. Fixes #27533 2015-03-02 14:20:42 +01:00
Jo Shields 092a04e4f7 Workaround for X509Certificate.RSA throwing an unhandled exception in ASN1 parsing of certificates with ECC public keys only. 2015-03-02 13:07:14 +00:00
Marek Safar fcb023636e Bump referencesource to mono-4.0.0-branch 2015-03-02 11:11:33 +01:00
Marek Safar b16f85b9dd [mcs] Add cloning to string interpolation expressions. Fixes #27525 2015-03-02 10:17:15 +01:00
Alexis Christoforides 5b7798b6c5 Bump to trigger build with https://github.com/xamarin/bockbuild/commit/b8ac90ecd1e89edd9ba62e3fe04581cb75f1d063 2015-03-01 12:09:54 -05:00
Zoltan Varga 709565592d [llvm] Increase the size of a parameter array which was too small for some arm64 calling conventions. 2015-02-27 13:33:54 -05:00
João Matos 85f7fefe8a Added "ld-flags" to pass extra linker flags to the AOT linker pipeline. 2015-02-27 17:27:16 +00:00
Rodrigo Kumpera e0873dee3b Remove explicit support for 2.0, it will now use 4.5 2015-02-27 11:07:44 -05:00
Zoltan Varga 26340997e5 [aot] Fix thumb support when using separate llvm modules. 2015-02-26 15:27:31 -05:00
Zoltan Varga 43743ac7f8 [runtime] Add a --disable-visibility-hidden flag to disable the usage of -fvisibility=hidden for now. 2015-02-26 15:20:59 -05:00
Rolf Bjarne Kvinge cfe89ef924 Ignore a few decimal tests on mobile, according to #27269
https://bugzilla.xamarin.com/show_bug.cgi?id=27269
2015-02-26 20:00:41 +01:00
Zoltan Varga 8a3a77dce1 [runtime] Disable the "bridge-implementation=tarjan,major=marksweep-conc|ms-conc-tarjan-bridge" sgen tests which currently fail. 2015-02-26 12:57:52 -05:00
Rolf Bjarne Kvinge 00251b8c11 Don't use _NSGetEnviron on arm64. 2015-02-26 13:55:41 +01:00
Rolf Bjarne Kvinge 2c78813a69 Restrict IOKit usage to desktop OSX.
IOKit is a private framework in iOS, so it can't be used (and
no headers are provided, so it doesn't even compile).
2015-02-26 13:52:16 +01:00
João Matos a9a759626a Fixed compilation on Linux targets without linux/serial.h.
/Users/builder/data/lanes/monodroid-mavericks-master/7de6731a/source/mono/support/serial.c:25:26: fatal error: linux/serial.h: No such file or directory
 #include <linux/serial.h>

The header is only available on Android NDK API level >= 21.
2015-02-26 12:10:03 +00:00
Alexander Köplinger ebf6644648 Remove EntityFramework from class libs
We currently ship a horribly outdated version of EF. This is unnecessary since EF is on NuGet and has an active set of users using it on Unix.

Miguel gave his +1 on the mailing list already.
2015-02-26 01:29:54 +01:00
Rodrigo Kumpera c5a2a17a55 Fix my last commit to properly include the tarjan test suite. 2015-02-25 19:16:20 -05:00
Rodrigo Kumpera a2042e361c Add the tarjan bridge to the test matrix. 2015-02-25 19:16:14 -05:00
Rodrigo Kumpera 1293675929 [sgen] Fix the sgen bridge test suite. Oh my. 2015-02-25 19:16:10 -05:00
Rodrigo Kumpera 5875dd48c2 [sgen-bridge] Fix all the bridges after the change to have descriptor loading happen outside of scanning.
This changes all bridges to use the _safe variant of sgen_obj_get_descriptor. Bridge processing happens in
the post-scan world, before objects get untagged.
2015-02-25 18:23:24 -05:00
Miguel de Icaza c1d60b3918 [Serial] Add support for high baud rates to MacOS 2015-02-25 16:32:43 -05:00
Miguel de Icaza 6e688fc5a8 [serial,signal] Add support for Linux arbitrary baud rates + drop Apple legacy poll support
This patch brings support for arbitrary baud rates in Linux, from patch:

https://bugzilla.xamarin.com/show_bug.cgi?id=8207

Which has been MIT licensed (see mono-devel-list).

In addition, while testing the patch, discovered that we are using
fakepoll.h on MacOS which was there to support Tiger-era broken poll
implementations.

The details about the lack of poll support come from this document
that is now only available on web.archive.org:

http://web.archive.org/web/20030604064847/http://developer.apple.com/technotes/tn2002/tn2071.html

And the original Mono bug that reported the problem in 2008, followed
by the fixes is reported and discussed here:

https://bugzilla.novell.com/show_bug.cgi?id=384227

The source of the problem, confirmed by an Apple employee at the time
(form the bug) is that poll sometimes results in returning POLLHUP
when a POLLIN was expected:

http://curl.haxx.se/mail/lib-2005-05/0122.html

This web site tracks the behavior of poll (POLLHUP and POLLIN) across
Posix implementations when you reach an end of file:

http://www.greenend.org.uk/rjk/tech/poll.html
2015-02-25 15:17:33 -05:00
Marek Safar ff2d07c4a1 [system.net.http] Add another workaround for incompatible mono Uri handling. Fixes #27386 2015-02-25 12:32:11 +01:00
Marek Safar 83d87aeb90 [System.Net.Http] Change relative uri test to not require internet access 2015-02-25 12:32:02 +01:00
Marek Safar ca9ee4b264 [Mono.XBuild.Tasks] Fixes versioning with newer than 4.0 special msbuild profiles 2015-02-24 18:11:00 -05:00
Rodrigo Kumpera 807ca43a59 Bump mono version to 4.0 2015-02-24 17:28:43 -05:00
Rodrigo Kumpera 7ca1857b8d Merge pull request #1592 from akoeplinger/remove-npgsql-4.0
Remove Npgsql from class libs (mono-4.0.0-branch)
2015-02-24 14:55:40 -06:00
Alexander Köplinger 51e5f8cc9b Remove Npgsql from class libs
This has been requested by the maintainers of Npgsql a few times already (https://bugzilla.xamarin.com/show_bug.cgi?id=23119) and we should do it for Mono 4.0.
Miguel gave his +1 on the mailing list already.
2015-02-24 21:50:42 +01:00
Marek Safar 46b86edb63 [facades] Add missing System.ServiceModel.Primitives forwarders to MT profile. Fixes #27338 2015-02-24 20:31:01 +01:00
Marek Safar ee2d91851a [system.net.http] Accept header with multiple values. Fixes #27352 2015-02-24 19:18:44 +01:00
Marek Safar 3e854a1f22 [build] 3.10 bump for bootstrap was too much 2015-02-24 09:01:52 +01:00
Marek Safar 4576568996 [system] Bump reference sources to get correct category names 2015-02-24 08:51:33 +01:00
Zoltan Varga 51a74a27da [runtime] Disable some dyncall/gsharedvt fullaot tests on amd64. 2015-02-23 19:50:03 -05:00
Zoltan Varga 7aa521b02c [bcl] Fix Console support on ios, the TextWriter class from the reference sources called TextWriter:Write(char), so stdout was never flushed. 2015-02-23 19:47:52 -05:00
Alexander Köplinger f3f1799700 Ensure MakeRelative() works even when basePath doesn't end in slash 2015-02-22 20:41:29 +01:00
Alexander Köplinger 0a8592dc5b [Microsoft.Build.Engine] Implement MakeRelative() predefined property function 2015-02-22 20:09:31 +01:00
Marek Safar 321bb7200c Merge pull request #1573 from akoeplinger/msbuild-import-empty
[Microsoft.Build.Engine] Ignore import with empty project attribute when condition is false
2015-02-21 13:22:01 +01:00
João Matos b92e728081 Merge pull request #1583 from akoeplinger/fix-genproj-line-endings
[genproj] Fix line endings in generated file to be CRLF
2015-02-20 20:14:15 +00:00
Atsushi Eno 684f9b08a5 Merge branch 'master' of github.com:mono/mono
(some commits occurred while I have been cherry-picking a lot of "they are
in import-system-xml branch but it works with existing sys.xml" stuff.)
work in master
2015-02-21 03:35:57 +08:00
Atsushi Eno 545cdaf8f7 [WCF] XmlWriter.WriteAttributeString(string,string) does not accept xml:*.
It needs LocalName. So use other overloads instead.
2015-02-21 03:33:23 +08:00
Atsushi Eno 6499ba871d [XLinq] create new instance of XmlSchemaInfo for each XObject from XmlReader.
In referencesource, XmlReader.SchemaInfo does not return different instances
for each node at its state but just returns the XmlReader itself (which
implements IXmlSchemaInfo). Hence, if we just set the corresponding
IXmlScemaInfo to each XObject, it results in inconsistent state.

This fixes two regressions in ExtensionsTest (XAttributeFailValidate and
XAttributeThrowExceptionValidate).
2015-02-21 03:32:44 +08:00
Atsushi Eno 923ed6b241 [Sys.Security] don't expect XmlNode.ChildNodes returns the same instance.
It did in mono implementation. It doesn't on referencesource.
2015-02-21 03:31:39 +08:00
Atsushi Eno d9184320f7 [Configuration] skip whitespaces in the settings xml.
This is required after we switch to referencesource, which somehow
preserves whitespaces during deserialization from xml.
2015-02-21 03:29:21 +08:00
Atsushi Eno 2951e3b6d8 [Xaml] XamlXmlWriter should flush output when disposing.
With referencesource, XmlWriter for TextWriter buffers the output.
When closing XamlXmlWriter, it does not flush the output, causing
the buffered XmlWriter output discarded in the wild.
2015-02-21 03:28:44 +08:00
Atsushi Eno 3001bd0d94 [WCF] for certain kind of Messages, do now write BodyContents twice. 2015-02-21 03:28:07 +08:00
Atsushi Eno a1d5c9c48d [Sys.Xml] when deserializing XmlNode, use XmlReader's NameTable. 2015-02-21 03:26:10 +08:00
Atsushi Eno abb3e7dcfc [WCF] fix wrong using scope on XmlWriter in security token serializer test. 2015-02-21 03:25:29 +08:00
Atsushi Eno cdb4002190 [WCF] do not use XmlReader.Name to check LocalName.
It won't match for prefixed ones.
2015-02-21 03:24:54 +08:00
Atsushi Eno 358275e836 [WCF] Do not expect XmlElement.FirstChild is non-whitespace here.
Fix several regressions caused by referencesource Sys.Xml import.
2015-02-21 03:24:12 +08:00
Atsushi Eno a0dece2329 [S.R.Serialization] fix referencesource glitch in XmlMtomDictionaryWriter.
MTOM writer didn't expect multiple top-level elements are rejected at
ConformanceLevel.Auto, neiher do against Write[Start/End]Document() with
such elements.

Also Flush is often needed before directly writing to the Stream(Writer).

EOLs handling was also inconsistent between referencesource and old mono.
2015-02-21 03:23:15 +08:00
Atsushi Eno a3383d1be5 [S.R.Serialization] add missing attributes in MS serialization namespace.
This fixes another regression which failed to load Test ns22.xsd.
2015-02-21 03:22:08 +08:00
Atsushi Eno 74e70ff985 [Sys.Xml] don't use XmlSchemaElement.ElementType anymore. MS doesn't use it.
XML Schema compilation is done in referencesource.
XmlSchemaImporter is based on mono code. Hence this glitch happened.

The following regression is fixed:

1) MonoTests.System.Xml.Serialization.XmlSchemaImporterTests.DefaultTypeTopLevelElementImportsAllComplexTypes : System.InvalidOperationException : 'Root' is missing.
at System.Xml.Serialization.XmlSchemaImporter.ImportTypeMapping (System.Xml.XmlQualifiedName name) [0x0005a] in /svn/mono/mcs/class/System.XML/System.Xml.Serialization/XmlSchemaImporter.cs:453
at MonoTests.System.Xml.Serialization.XmlSchemaImporterTests.DefaultTypeTopLevelElementImportsAllComplexTypes () [0x00039] in /svn/mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlSchemaImporterTests.cs:1104
at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
at System.Reflection.MonoMethod.Invoke (System.Object obj, BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00054] in /svn/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
2015-02-21 03:19:06 +08:00
Atsushi Eno d41451bcbf Our XmlDictionaryWriter implementation expects XmlReader at non-Initial state.
It is to fix glitch between mono Sys.Xml and referencesource.
2015-02-21 03:16:58 +08:00
Atsushi Eno c56064b05c [Sys.Data] DataSet.ReadXmlSchema(): use LocalName instead of Name on XmlReader.
MS referencesource Sys.Xml uncovered this bug.
2015-02-21 03:16:15 +08:00
Zoltan Varga 2202e97c33 [aot] Fix the emission of llvm plt entries. 2015-02-20 14:00:17 -05:00
Marek Safar cfbb82b747 [corlib] Fixes build with old UnmanagedMemoryStream 2015-02-20 18:46:31 +01:00
Atsushi Eno 49d79191ca Add missing new I18N DefaultEncoder class. 2015-02-21 00:52:26 +08:00
Atsushi Eno 3f355da212 Add old mono Encoder and use it in MonoEncoding to keep compatibility.
There was some glitch in CP932 encoding and referencesource Encoder
that caused error in Convert(), shown in System.XML tests.
To avoid this, bring back old Encoder as we used before and keep
compatible processing.

It might be buggier, but doesn't regress. We may be able to bring nlp-
based Encodings later too.
2015-02-21 00:52:20 +08:00
Zoltan Varga 392200a812 [runtime] Export the GC bridge api functions. 2015-02-20 11:51:19 -05:00
Miguel de Icaza 0e8701a161 Merge pull request #1582 from zevane/patch-1
Make the class thread-safe
2015-02-20 11:23:50 -05:00
Marek Safar 6800659e8c [corlib] Remove ResourceCloseHandler usage 2015-02-20 17:07:15 +01:00
Marek Safar 01db1cc9ad [corlib] Add more internal apis 2015-02-20 15:09:14 +01:00
Marek Safar ed2510cc14 [build] Handle multiple entries in RESOURCE_STRINGS 2015-02-20 13:34:18 +01:00
Marek Safar 7a57bd6b3d Bump reference sources to revert Add read-only interfaces to some collections 2015-02-20 11:25:23 +01:00
Marek Safar 8e90a963d6 Use more resource text strings from reference sources 2015-02-20 11:16:18 +01:00
Marek Safar 71533001b8 [System.Runtime.Serialization] Makefile cleanup 2015-02-20 09:57:30 +01:00
Marek Safar f364eca194 [System.Numerics] Cleanup Makefile 2015-02-20 09:52:44 +01:00
Marek Safar b1941bc08a [System.ComponentModel.DataAnnotations] Makefile clean-up 2015-02-20 09:44:37 +01:00
zevane b3ddd74efb Make the class thread-safe
If two threads request the same section, which isn't yet cached, both try to insert it into the cache, causing a "Key duplication when adding...". It's neccesary to lock the getter. This solves bugs #5263, #7785, #18303
2015-02-20 09:12:47 +01:00
Marek Safar 754793df9e [corlib] Switch to official mscorlib.txt 2015-02-20 08:49:17 +01:00
Miguel de Icaza 414d11f976 Bring referencesource messages that were just published by Microsoft 2015-02-19 21:02:49 -05:00
Zoltan Varga 285f867593 [aot] Fix the emission of dwarf debug info. 2015-02-19 20:24:38 -05:00
Zoltan Varga 5fc41fcb56 [aot] Emit dwarf emission on arm64. 2015-02-19 20:02:39 -05:00
Zoltan Varga af3c010407 [llvm] Fix a bug introduced by 61ae03fef1. 2015-02-19 18:53:37 -05:00
Zoltan Varga c3611d4d3b [llvm] Mark methods with the NOINLINING attribute as non-inlinable. 2015-02-19 17:17:20 -05:00
Zoltan Varga 61ae03fef1 [llvm] Refactor the calling convention handling code a bit, add support for returning fp structures by value. 2015-02-19 17:04:07 -05:00
Ludovic Henry 986e58d530 [tpl] Increase wait timing in test suite to adapt to the slower ramp up of the ThreadPool 2015-02-19 15:49:19 -05:00
Zoltan Varga 127602a843 [aot] Enable LLVM level inlining. 2015-02-19 14:34:33 -05:00
Marek Safar fbe7c55a56 [system.web] Tests update 2015-02-19 20:12:52 +01:00
Marek Safar 6e488234ae [WindowsBase] Implement Vector formattable ToString 2015-02-19 20:12:52 +01:00
Marek Safar ea43322c29 [corlib] BufferedStream from reference sources 2015-02-19 20:12:51 +01:00
Zoltan Varga 689a615a71 [llvm] Mark methods with clauses as noinline. 2015-02-19 14:06:20 -05:00
Zoltan Varga e869cc56a5 [jit] Fix the overflow checks in the liveness2 pass since the liveness ranges are stored as signed ints. 2015-02-19 14:05:51 -05:00
Zoltan Varga ae9d99d2d3 [aot] Fix catching exceptions in gshared methods on amd64. 2015-02-19 13:26:23 -05:00
Alexander Köplinger 042a9afd50 [genproj] Fix line endings in generated file to be CRLF
The template uses CRLF everywhere, so we should generate the same to avoid mixed line endings.
2015-02-19 19:23:23 +01:00
Zoltan Varga eb7ed887ac [llvm] Mark the mono_aot_personality () function as used, to prevent llvm from optimizing it away. 2015-02-19 12:10:02 -05:00
Zoltan Varga 08b8f74db5 [runtime] Export a few functions needed by xam.mac. 2015-02-19 11:41:11 -05:00
Jo Shields 2750f4970d Add ReferenceSources/mscorlib.txt to EXTRA_DIST (fixes distcheck) 2015-02-19 16:11:28 +00:00
Marek Safar 65347a166e [corlib] Text streams from reference sources 2015-02-19 17:04:14 +01:00
Marek Safar ce4e2497be [corlib] Use public TextWriter.Synchronized for Console synchronization and leave stream closing handling to underlying stream 2015-02-19 16:42:57 +01:00
Marek Safar 1425ace040 [corlib] Stream, MemoryStream from reference sources 2015-02-19 13:04:46 +01:00
Marek Safar 8da38a9e4a [corlib] Access null stream using public property 2015-02-19 13:04:46 +01:00
Marek Safar ffc36ef3bd [corlib] Rename IsDirectorySeparator method to match reference sources 2015-02-19 13:04:46 +01:00
Alex Rønne Petersen 9af7d9083a Stop building with -Wdeclaration-after-statement since we're C99 now. 2015-02-19 11:04:59 +01:00
Zoltan Varga f8c5acaf45 [aot] Fix an assertion. 2015-02-18 20:35:47 -05:00
Zoltan Varga 2c1b64477b [llvm] Emit null checks for remainders as well. 2015-02-18 19:15:12 -05:00
Zoltan Varga 5e0b127e15 [llvm] Emit null checks in div opcodes if needed. 2015-02-18 19:04:51 -05:00
Zoltan Varga a0c1fb5a1a [aot] Fix binary search in the code offsets table when emitting llvm code separately. 2015-02-18 19:04:08 -05:00
Zoltan Varga 98316e0be1 [aot] Fix the computation of LLVM code ranges. 2015-02-18 18:24:49 -05:00
Jo Shields 2d6092f45e Ensure check-seq-point target exits immediately on failure. 2015-02-18 23:14:19 +00:00
Zoltan Varga 2c69ccd9f0 [jit] Disable llvm support for the atomic load/store opcodes for now to fix corlib test failures. 2015-02-18 17:31:02 -05:00
Zoltan Varga 77f4176af0 [aot] Handle separate blocks of llvm and jitted code correctly. 2015-02-18 17:10:57 -05:00
Mark Probst fee8ae7ef6 [sgen] Correctly calculate size of zero-based one-dimensional non-vector arrays. 2015-02-18 12:43:31 -08:00
Marek Safar a803d17038 [mcs] Make compiler output deterministic. Fixes #26842 2015-02-18 20:02:31 +01:00
Zoltan Varga 28a2664d4a Merge pull request #1576 from McSherry/patch-1
revises GZipStream ctor parameter names
2015-02-18 13:41:08 -05:00
Zoltan Varga 04ba85af27 [runtime] Really fix the loadable LLVM build. 2015-02-18 13:39:08 -05:00
Liam McSherry dd939ec86a revises GZipStream ctor parameter names
By changing the names of the parameters, code that uses .NET GZipStream constructors[1][2] with named parameters can use this GZipStream without change.

[1]: https://msdn.microsoft.com/en-us/library/as1ff51s(v=vs.110).aspx
[2]: https://msdn.microsoft.com/en-us/library/27ck2z1y(v=vs.110).aspx
2015-02-18 18:32:43 +00:00
Jo Shields 9f5a7ae769 Just avoid BSD sed altogether. 2015-02-18 18:29:01 +00:00
Jo Shields 85f78490d2 More fixes for BSD sed breaking check-seq-point target 2015-02-18 17:42:15 +00:00
Jo Shields dad995933c Further fixes to check-seq-point test 2015-02-18 17:17:21 +00:00
Jo Shields afc70b2b7e Fix test suite on OSX 2015-02-18 16:54:54 +00:00
Zoltan Varga 5e4ee3ccea [runtime] Fix the loadable LLVM build. 2015-02-18 11:43:32 -05:00
Marek Safar 038b3b6cea Bump ikdasm to fix crashes on mobile mscorlib 2015-02-18 17:05:16 +01:00
João Matos 08ea547ec4 Merge pull request #1575 from mono/revert-1574-patch-1
Revert "revises GZipStream ctor parameter names"
2015-02-18 16:00:06 +00:00
João Matos f0a399e640 Revert "revises GZipStream ctor parameter names" 2015-02-18 15:59:39 +00:00
João Matos fb9ae0f835 Merge pull request #1574 from McSherry/patch-1
revises GZipStream ctor parameter names
2015-02-18 15:59:16 +00:00
Liam McSherry 1f07b1320c revises GZipStream ctor parameter names
By changing the names of the parameters, code that uses .NET GZipStream constructors[1][2] with named parameters can use this GZipStream without change.

[1]: https://msdn.microsoft.com/en-us/library/as1ff51s(v=vs.110).aspx
[2]: https://msdn.microsoft.com/en-us/library/27ck2z1y(v=vs.110).aspx
2015-02-18 15:55:01 +00:00
João Matos 8e87cce42c [profiler] Fixed an Android build regression introduced by 2b74940f64. 2015-02-18 15:29:57 +00:00
Zoltan Varga bfafeddc2b [runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported. Use a separate SHARED_CFLAGS variable so it only affects a subset of libs. 2015-02-18 08:12:32 -05:00
Zoltan Varga 0927b86347 Revert "[runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported."
This reverts commit 8a5a230aec.

Revert this as it still causes test failures.
2015-02-18 08:11:22 -05:00
João Matos 7e9504a10d [monodis] Fixed building against LLVM-compiled Mono. 2015-02-18 12:49:01 +00:00
João Matos b50b381226 Merge pull request #1572 from directhex/emit-nunit-xml-in-unmanaged-tests
Emit NUnit representation of check-seq-points target.
2015-02-18 12:26:09 +00:00
Jo Shields a34e257fd2 Emit NUnit representation of check-seq-points target.
This generates an XML representation of the check-seq-points target,
as separate tests, which can be easily tracked by anything which
parses NUnit output (e.g. Jenkins or other CI systems). For example,
we are currently regressed on this on ARM.
2015-02-18 12:10:39 +00:00
Marek Safar da706a2058 [corlib] Removes extra bufffer from FileStream async mode writes. Fixes #27086 2015-02-18 12:56:36 +01:00
Martin Baulig a20a0459be Merge pull request #1464 from akoeplinger/fix-portable-target
[xbuild] Only execute PCL target "ImplicitlyExpandTargetFramework" when corresponding property is true
2015-02-18 08:12:08 +01:00
Alexander Köplinger bf3d9609ba [Microsoft.Build.Engine] Ignore import with empty project attribute when condition is false
<Import Project="$(Variable)" Condition="false" /> causes an exception otherwise when Variable is not set.
Also added a test for condition referencing extension path after discussion in https://github.com/akoeplinger/mono/commit/f13d9cb5dacbb5c9f758d6dd8b9aacf46b5508b6
2015-02-18 07:38:41 +01:00
Miguel de Icaza aeb24275bc Merge pull request #1563 from directhex/emit-nunit-xml-in-unmanaged-tests
Generate NUnit interpretation of whether "mono --regressions" passed
2015-02-17 23:27:58 -05:00
Zoltan Varga 8a5a230aec [runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported. 2015-02-17 19:05:03 -05:00
Zoltan Varga 2b74940f64 [runtime] Link the logging profiler against eglib. 2015-02-17 19:03:39 -05:00
Zoltan Varga 065f41d168 [runtime] Export mono_threads_attach_tools_thread (). 2015-02-17 19:03:39 -05:00
Marek Safar 4d91c8e7d2 [build] Remove misused bootstrap profile definition 2015-02-17 21:58:23 +01:00
Marek Safar 451e14e4c8 [corlib] Remove duplicate source files 2015-02-17 21:43:23 +01:00
Marek Safar c495250fde [corlib] Replace resource keys with actual messages during compilation 2015-02-17 21:43:22 +01:00
Rodrigo Kumpera 04eeb70c8c Merge pull request #1570 from mono/fix27010
Bug 27010 - Difference in Assembly.GetExportedTypes with .NET
2015-02-17 13:49:05 -06:00
Alex Rønne Petersen 8bf480fc62 Merge pull request #1571 from evincarofautumn/fix-warning
[utils] Fix warning in Makefile.am.
2015-02-17 19:58:14 +01:00
Jon Purdy f14d23b7f0 [utils] Fix warning in Makefile.am. 2015-02-17 10:56:15 -08:00
João Matos b8dec77eea [mini] Improve the driver to handle more cases of incompatible cross-compilation targets. 2015-02-17 16:12:49 +00:00
João Matos ac8ae330c7 [metadata] Do not try to use host context members when cross-compiling. 2015-02-17 16:12:11 +00:00
João Matos 85e5ebbfa9 [metadata] Add missing ARM64 object offsets.
This fixes the mobile products build with Mono master.
2015-02-17 16:11:21 +00:00
Zoltan Varga 0ba6d1777d [aot] Fix the emission of ElementAddr wrappers. 2015-02-17 07:46:11 -05:00
Zoltan Varga 4c8a1a6733 [runtime] Link monodis against libmonoruntime instead of libmono which can be a dynamic lib. 2015-02-17 06:59:29 -05:00
Zoltan Varga ff2cfae862 [gsharedvt] Implement support for multi-dimensional arrays in gsharedvt methods. 2015-02-17 06:57:43 -05:00
Zoltan Varga acbe5f52d5 Fix a warning. 2015-02-17 05:44:58 -05:00
Marek Safar 673e8fa8ee [mcs] Single name meaning relaxation to match roslyn 2015-02-17 10:59:33 +01:00
Alex Rønne Petersen 33ad107825 Update refsrc to get read-only interface changes for System/System.Core. 2015-02-17 10:53:10 +01:00
Marek Safar 877e8ce941 [mcs] Fixes check for overriden auto-properties. 2015-02-17 08:14:21 +01:00
Ungureanu Marius 818d229538 Bug 27010 - Difference in Assembly.GetExportedTypes with .NET 2015-02-17 06:41:12 +02:00
Alex Rønne Petersen 235f543d94 [mini] Fix a crash on armel. 2015-02-17 02:04:15 +01:00
Zoltan Varga 6ee1b1b565 [jit] Add tests for arm64 gsharedvt argument passing. 2015-02-16 16:07:03 -05:00
Zoltan Varga 175c1a521d [jit] Add tests for arm64 gsharedvt argument passing. 2015-02-16 15:20:17 -05:00
Alexander Köplinger 8f7a551c0c [Microsoft.Build.Tasks] Rethrow exception in Copy task
This way we don't lose the original stacktrace.
2015-02-16 19:05:00 +01:00
Marek Safar 724c1becc1 Add new test 2015-02-16 17:03:50 +01:00
Marek Safar ed517ad778 [mcs] Implements dictionary initializers on pointer types 2015-02-16 16:48:24 +01:00
Miguel de Icaza aef0b3e04c Merge pull request #1542 from ninjarobot/UriTemplateMatchException
Fix to UriTemplate.Match to properly handle query parameters without a v...
2015-02-16 10:19:44 -05:00
Miguel de Icaza 5715cdc582 [System.ServiceModel] Prevent server crash when client disconnect
This patch is an updated version of a pull request (377) from Rob
Wilkens to fix #5926
2015-02-16 10:01:22 -05:00
João Matos bccf5cf121 [aot] Re-organize JSON dumping code. 2015-02-16 12:48:05 +00:00
João Matos d9234357f6 Revert "[aot] Re-organize JSON dumping code."
This reverts commit 25969466b5.
2015-02-16 12:46:29 +00:00
João Matos b4926395c6 [git] Ignore Doxygen-related generated files. 2015-02-16 12:39:03 +00:00
Zoltan Varga 25969466b5 [aot] Re-organize JSON dumping code. 2015-02-16 12:38:40 +00:00
Marek Safar bc57fda921 Merge pull request #1568 from akoeplinger/xbuild
[Microsoft.Build.Tasks] Implement retries in Copy task and add a stub.
2015-02-16 07:54:54 +01:00
Atsushi Eno 90b1124402 Merge branch 'import-text-encoding-2' 2015-02-16 14:34:19 +08:00
Alexander Köplinger 40c0dfcf93 [Microsoft.Build.Tasks] Add stub for UseHardlinksIfPossible to Copy task
Creating hardlinks in .NET doesn't have a nice API and using Mono.Unix/Pinvoke doesn't
seem worth the effort at this point since the feature is off by default on msbuild as well.
2015-02-16 01:50:07 +01:00
Alexander Köplinger baaf07c104 [Microsoft.Build.Tasks] Implement retries in Copy task 2015-02-16 01:38:06 +01:00
Atsushi Eno e4b2bc75aa [sys.xaml] serialize string value as string, do not try ValueConverter.
Fixed some xwt object serialization.
2015-02-16 03:32:49 +08:00
Zoltan Varga bcd70a77a7 [jit] Fix a regression introduced by 00a28a7dfd which disabled liveness2 for most methods. 2015-02-14 15:51:11 -05:00
Zoltan Varga bca66a090d [arm64] Add a test for vtype by ref returns in dyn calls. 2015-02-13 17:54:31 -05:00
João Matos 874d17321d [runtime] Fixed TLS detection on AMD64 to support cross-compilation. 2015-02-13 16:45:46 +00:00
Marek Safar 52c33f00ff [mcs] Better error reporting after delegate probing failed. Fixs #27043 2015-02-13 17:42:41 +01:00
João Matos e3279063de [aot] Added JSON dumping support.
This is enabled by passing "aot=dump" to the Mono AOT driver and will create a JSON file in the working directory with the name of the assembly.

It's still a work-in-progress and will see improvements in the data dumped as it's needed.
2015-02-13 16:41:07 +00:00
Marek Safar b9c8a612b7 [mcs] Set fixed buffer layourt wihout StructLayoutAttribute when possible. Fixes #27020 2015-02-13 16:49:22 +01:00
Marek Safar 8d3c6d44f8 [corlib] Random from reference sources 2015-02-13 15:05:43 +01:00
Marek Safar da9546edfd [corlib] MissingMember exceptions from reference sources 2015-02-13 14:58:40 +01:00
Marek Safar 09b16951bc [corlib] UnitySerialization from reference sources 2015-02-13 14:45:46 +01:00
Marek Safar 8157ba59ce [system.net.http] Parsing of nested parens inside comment. Fixes #27036 2015-02-13 14:37:32 +01:00
Marek Safar 1128af49cf [mcs] Resolve using aliases on demand to fix issue with nested types. Fixes #27001 2015-02-13 14:37:31 +01:00
João Matos 08014c4629 [monodis] Attempt to fix the Cygwin build.
CCLD     monodis.exe
../../mono/metadata/.libs/libmonoruntimesgen-static.a(libmonoruntimesgen_static_la-opcodes.o): In function `mono_opcode_name':
/cygdrive/c/projects/mono-817/mono/metadata/opcodes.c:63: multiple definition of `mono_opcode_name'
../mini/.libs/libmonosgen-2.0.dll.a(d001720.o):(.text+0x0): first defined here
collect2: error: ld returned 1 exit status
2015-02-13 12:43:06 +00:00
Atsushi Eno f47937f8f3 avoid reflection in EncodingHelper.
as per https://github.com/mono/mono/pull/1566#discussion_r24653304
2015-02-13 18:25:49 +08:00
Atsushi Eno 59dc2b42c8 [encoding] import referencesource encoding foundation types.
This change does not involve Windows-specific NLS-based encodings.
We will be still using I18N assemblies until we make more grand design
changes (Xamarin products premise those assemblies).

This also fixes bug #23771 and probably more.
2015-02-13 16:41:05 +08:00
Zoltan Varga 2a3385da86 Fix a warning. 2015-02-13 02:16:16 -05:00
Alex Rønne Petersen 61e8b5e6d0 [mini] Add a MONO_ARM_FORCE_SOFT_FLOAT environment variable. 2015-02-13 08:08:44 +01:00
Zoltan Varga 8a3b8e716f [runtime] Overwrite logging profiler output files automatically. 2015-02-13 00:39:48 -05:00
Zoltan Varga f16a4a1975 [runtime] Export mono_personality (), which is accessed from llvm compiled code. 2015-02-13 00:29:24 -05:00
Zoltan Varga b45199d288 [corlib] Fix a race in LazyTest.EnsureSingleThreadSafeExecution (). 2015-02-13 00:15:52 -05:00
Zoltan Varga 82554c4e89 [runtime] Add a SHARED_CFLAGS autoconf var which can be used to pass the -fvisibility=hidden flag. 2015-02-13 00:10:51 -05:00
Rodrigo Kumpera 19a22ede0d Merge pull request #1439 from BrzVlad/feature-managed-allocator
[jit] Optimize the managed allocator fastpath for small objects
2015-02-12 17:43:52 -06:00
Atsushi Eno 93ce056a76 Merge pull request #1496 from echampet/serializers
System.Xml.Serialization: fix xml serializers generation for Web Services
2015-02-13 05:08:10 +08:00
Atsushi Eno 33694c02b3 [encoding] as part of referencesource import, use new EncodingHelper class.
This will remain after importing referencesource and offer mono-only
internals for some classes. This involves icall (owner class) change.
2015-02-13 04:24:47 +08:00
Marek Safar 2ca5117fd2 [system] Mark ping MT implementation as broken 2015-02-12 19:09:08 +01:00
João Matos ccf89b6b5b [runtime] Fixed TLS detection on x86 to support cross-compilation. Fixes #26969.
https://bugzilla.xamarin.com/show_bug.cgi?id=26969.
2015-02-12 17:40:13 +00:00
Zoltan Varga 83ae5b92ac [runtime] Fix an automake warning. 2015-02-12 12:29:37 -05:00
Zoltan Varga 679f9b44a5 [runtime] Fix an initialization race when using custom marshallers. 2015-02-12 12:13:54 -05:00
João Matos 98a88d8009 Merge pull request #1534 from haf/bugs/hmac-wrong-keysizes
Bugs/hmac wrong keysizes
2015-02-12 16:46:00 +00:00
Marek Safar 72eb18f84d [system] More linker friendly tests 2015-02-12 17:00:34 +01:00
Jo Shields 12baa6e696 Generate NUnit interpretation of whether "mono --regressions" passed 2015-02-12 15:22:17 +00:00
Zoltan Varga d7ae2816fe Merge pull request #1562 from vkargov/master
[runtime] Mark TLS variables as explicitly used
2015-02-12 10:03:40 -05:00
Vladimir Kargov 16ee025230 [runtime]
Mark TLS variables as explicitly used to avoid their unwarranted deletion
by the compiler overlooking their usage in inline assembly sections.
2015-02-12 17:45:34 +03:00
João Matos 90185288b1 [aot] Fixed LLVM assembly generation for non-Mach targets.
Fixes bugzilla #26964.
2015-02-12 13:42:46 +00:00
Marek Safar 45448a3f16 [corlib] Add timeout to more tests 2015-02-12 14:21:24 +01:00
Zoltan Varga 9eea9b6d70 [aot] Fix emission of symbol sizes which got broken by 05cd4225b2. 2015-02-12 07:49:08 -05:00
Marek Safar 3af8147e4d [system] Add old monotouch test codepath 2015-02-12 13:24:16 +01:00
Marek Safar 3d3c8b9bc6 [system.core] Fix wrong 405f9534df 2015-02-12 13:20:10 +01:00
Zoltan Varga 0871f1f266 Revert "[runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported."
This reverts commit 90e86725ac.

Revert this as it causes many test failures.
2015-02-12 06:47:09 -05:00
Zoltan Varga b64c24b4ea [runtime] Export mono_gc_toggleref_add (). 2015-02-12 06:45:45 -05:00
Zoltan Varga 90e86725ac [runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported. 2015-02-12 05:22:52 -05:00
Zoltan Varga 17eadbf010 [runtime] Define MONO_API_EXPORT properly for gcc, and define MONO_DLL_EXPORT so it is actually used during the build. 2015-02-12 05:21:50 -05:00
Zoltan Varga 029753034f Revert "[runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported."
This reverts commit beb1463b6c.

Revert this for now as it breaks loading symbols from the mono executable on osx.
2015-02-12 04:51:06 -05:00
Marek Safar 52227a1e6d [runtime] Return strongly typed array from GetModules to match managed signature. Fixes a crash with strongly typed enumerator 2015-02-12 10:09:06 +01:00
Marcos Henrich b3aec8113a [corlib] Fixes commit ceef1e2.
We want to remove the module check from GetMethodToken not SetUserEntryPoint.
2015-02-12 08:59:21 +00:00
Zoltan Varga 4ef4090a22 [runtime] Export symbols from libtest. 2015-02-12 03:53:26 -05:00
Zoltan Varga 250cd40b86 [runtime] Remove unused MONO_ARCH_SAVE_REGS declarations. 2015-02-12 03:46:49 -05:00
Zoltan Varga b34c3f6f64 [jit] Remove unused MONO_ARCH_SAVE_REGS declarations. 2015-02-12 03:32:58 -05:00
Zoltan Varga d9259e59e1 [monodis] Build monodis against the static mono libraries. 2015-02-12 03:04:39 -05:00
Zoltan Varga beb1463b6c [runtime] Use -fvisibility=hidden so only symbols marked with MONO_API are exported. 2015-02-12 02:25:19 -05:00
Sebastien Pouliot cfc0d6fc73 [linker] Do not update the Scope on TypeSpecification (fix mmp regression tests) 2015-02-11 15:38:48 -05:00
Zoltan Varga 6f572dcc58 Merge pull request #1561 from main--/patch-1
Only call string.Format in Debug.Assert if really necessary
2015-02-11 13:49:53 -05:00
main() 2e6efb3149 Only call string.Format in Debug.Assert if really necessary
Right now (without this change), Debug.Assert **always** formats its string parameters, even if doing so wouldn't be necessary because the condition is true. This has a huge impact on code that asserts frequently because it assumes that calling Assert(true, ...) is cheap.
2015-02-11 19:42:29 +01:00
Marek Safar ceef1e2379 Merge pull request #1560 from esdrubal/xlstregression
[corlib] ModuleBuilder.GetMethodToken no longer has a module check.
2015-02-11 17:17:27 +01:00
Marcos Henrich 9eb81476bd [corlib] ModuleBuilder.GetMethodToken no longer has a module check.
.NET implementation is able to get method tokens from other modules.
This was causing a regression on a System.Xml.Xsl.XslTransformTests.Bug487065 while using referencesource's System.Xml implementation.
2015-02-11 15:59:37 +00:00
Marcos Henrich 1e7a4a2114 [corlib] Test GetMethodToken ability to get other modules' tokens.
.NET implementation is able to get method tokens from other modules.
2015-02-11 15:59:36 +00:00
João Matos f1006fbbe0 [msvc] Upgrade the projects to require VS2013. 2015-02-11 15:55:43 +00:00
Alex Rønne Petersen 628f3d998b Use -std=gnu99 as we rely on the linux macro in some places. 2015-02-11 16:50:59 +01:00
Marek Safar 2326fa0721 Bump reference sources 2015-02-11 16:42:40 +01:00
Zoltan Varga 46357aee0b [runtime] Enable C99 mode. 2015-02-11 10:32:34 -05:00
Zoltan Varga 984a13d908 [runtime] Use ISO C __typeof__ instead of typeof () in one place. 2015-02-11 10:32:13 -05:00
Zoltan Varga 3b85df9c0d Fix the loadable llvm build. 2015-02-11 09:44:45 -05:00
Sebastien Pouliot b6d6280821 [linker] Ignore null type arguments in MarkWithResolvedScope
It's ignored in MarkType but it breaks calling Resolve in this case
2015-02-11 09:01:35 -05:00
Marek Safar 8db46e61fd [corlib] Fixes build 2015-02-11 14:04:35 +01:00
Zoltan Varga a42f4d8d22 Merge pull request #1559 from directhex/emit-nunit-xml-in-unmanaged-tests
Add NUnit XML emission to the managed runtime test runner.
2015-02-11 08:00:18 -05:00
Jo Shields 84a8428de1 Add NUnit XML emission to the managed runtime test runner.
This makes it easy to plug failures from the runtime tests into a visualisation, such as Jenkins' jUnit display system.
2015-02-11 12:48:45 +00:00
Zoltan Varga 078968540f Make the managed test runner the default in mono/tests, run with make M=0 to use the old one. 2015-02-11 07:47:39 -05:00
Zoltan Varga 9b617125bd [llvm] Maps structs made up of floats/doubles to llvm structs containing floats. 2015-02-11 07:02:45 -05:00
Marek Safar 4e27a21367 [system] Fix ping process exit code check 2015-02-11 12:04:50 +01:00
Marek Safar f97001e2c8 [system] updates fixed test 2015-02-11 10:47:54 +01:00
Marek Safar 405f9534df [system.core] Update aes test to match imported code 2015-02-11 09:43:17 +01:00
Marek Safar ec2e126dfd [mcs] Additional fix for #26892 2015-02-11 09:21:20 +01:00
Sebastien Pouliot d07822286c [linker] Resolve types inside custom attributes since they might refer to types in assemblies we won't be keeping [#26752]
Custom attributes encoding means it's possible to have a scope that will
point into a PCL facade even if we (just before saving) will resolve all
type references.

Since all other references can be made on the _real_ assembly and that
we do not want to include any facade assembly just for this we need to
resolve those type and update their scope.
2015-02-10 21:04:02 -05:00
João Matos 325744cb85 [build] Fixed the MSVC build. 2015-02-10 15:14:16 +00:00
Marek Safar 9b9b96980b [corlib] Guid from reference sources 2015-02-10 15:42:13 +01:00
Marek Safar 86e2bada8a [mcs] Fixes failing test 2015-02-10 15:42:13 +01:00
Marcos Henrich b94c4cdce1 [corlib] Calling 'tzi.exe -i' now prints olson transitions. 2015-02-10 10:44:35 +00:00
Marcos Henrich 7169eeb5e0 [corlib] Updated make target tzi.exe 2015-02-10 10:39:29 +00:00
Marcos Henrich 8473c6db7e Moved android-dump-tzdata make target to corlib.
Reason: All TimeZoneInfo related files are now all in corlib directory.
2015-02-10 10:32:30 +00:00
Zoltan Varga 2f95909242 Merge pull request #1557 from StephenMcConnel/bug-26887
Prevent right click from triggering ToolStripItem.HandleClick
2015-02-10 04:25:34 -05:00
Marek Safar 158487fe94 Rename binary reference assemblies location 2015-02-10 10:21:29 +01:00
Marek Safar 85ee5582f6 [eval] Add C#6 using handling 2015-02-10 10:12:43 +01:00
Zoltan Varga e26e45cf2f Merge pull request #1558 from ermshiperete/fixCrash
[MWF] Fix NullReferenceException introduced by commit a080a7d
2015-02-10 04:05:26 -05:00
Damien Daspit f7593c22b0 [MWF] Fix NullReferenceException introduced by commit a080a7d
Change-Id: I5709063cc7eecc01fd1e2978cd8aac096060c31e
2015-02-10 09:59:50 +01:00
Marek Safar a74bac2da2 [mcs] Fixed casts rules don't apply to strings and arrays. Fixes #26892 2015-02-10 09:31:22 +01:00
Marek Safar c7a4778737 [mcs] Resolve delegate optional parameters only once. Fixes #26840 2015-02-10 08:49:50 +01:00
Zoltan Varga 8562a498f3 [jit] Factor out the gsharedvt constrained call handling code into a separate function. 2015-02-10 02:27:13 -05:00
Zoltan Varga 382cf74c98 [jit] Fix some issues with constrained gsharedvt calls to be able to handle some cases encountered with the new MS reference source code. 2015-02-10 02:20:32 -05:00
Zoltan Varga b8f1a79295 Increase some trampoline buffer sizes. 2015-02-09 23:08:57 -05:00
Zoltan Varga d7b1944dce Bump referencesource. 2015-02-09 22:40:50 -05:00
Zoltan Varga c83aeed35f Bump referencesource to e6af770c424af46f78d3b8f90eebbb2e0d7953a2. 2015-02-09 22:35:07 -05:00
Alex Rønne Petersen 23fa25b4b5 Revert "[mini] Implement atomic exchange with xchg on x86."
This reverts commit c96e58280c.

Getting this to work right with regards to register allocation
is turning out to be more complicated than it seems. Going to
abandon this for now.
2015-02-10 03:01:33 +01:00
Alex Rønne Petersen c96e58280c [mini] Implement atomic exchange with xchg on x86. 2015-02-10 01:49:18 +01:00
Stephen McConnel e9cf1dc44a Prevent right click from triggering ToolStripItem.HandleClick
This fixes https://bugzilla.xamarin.com/show_bug.cgi?id=26887.
2015-02-09 18:39:18 -06:00
Zoltan Varga 8856edd6d3 Disable some full-aot tests on amd64 since it doesn't support dyn calls/gsharedvt. 2015-02-09 19:09:21 -05:00
Alex Rønne Petersen 0366b81069 [mini] Implement atomic exchange with xchg on amd64. 2015-02-09 23:41:30 +01:00
Marek Safar d2994b1b3d [corlib] Remove unused file 2015-02-09 23:15:16 +01:00
Marek Safar 8d9e34a098 [corlib] Keep file names ordered 2015-02-09 23:14:45 +01:00
Marek Safar 1bfa0567dc Merge pull request #1556 from atsushieno/import-text-encoding
import referencesource CharUnicodeInfo and remove some runtime char tables.
2015-02-09 20:09:04 +01:00
Alex Rønne Petersen 8aaed197ca Revert "[mini] Implement atomic exchange with xchg on x86/amd64."
This reverts commit 1a319806fe.

This seems to cause memory corruption that results in random
SGen crashes, especially in Roslyn.
2015-02-09 19:32:15 +01:00
Ludovic Henry 449666271a [runtime] Lower log level of "counters not enabled" message in counters 2015-02-09 13:12:11 -05:00
João Matos 48b7a501b0 Initialize the counters support before registering new ones.
This bug manifests itself in mkbundle'd programs that use the machine config support. Under this case, we can end up registering counters before initializing the counter support in the runtime:

```
* thread #1: tid = 0x141dec, 0x003ebdff mtouch-32`mono_counters_register(name=0x0042f7e3, type=2048, addr=0x00b81288) + 31 at mono-counters.c:218, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
  * frame #0: 0x003ebdff mtouch-32`mono_counters_register(name=0x0042f7e3, type=2048, addr=0x00b81288) + 31 at mono-counters.c:218
    frame #1: 0x0025c3f6 mtouch-32`mono_loader_init + 198 at loader.c:106
    frame #2: 0x0025f005 mtouch-32`mono_dllmap_insert(assembly=0x00000000, dll=0x00d0a0c0, func=0x00000000, tdll=0x00d0a0d0, tfunc=0x00000000) + 53 at loader.c:1321
    frame #3: 0x002c28ca mtouch-32`dllmap_start(user_data=0x00d0a0b0, element_name=0x00d0a0a0, attribute_names=0x00d0a030, attribute_values=0x00d0a040) + 698 at mono-config.c:290
    frame #4: 0x002c2010 mtouch-32`start_element(context=0x00d09fa0, element_name=0x00d0a0a0, attribute_names=0x00d0a030, attribute_values=0x00d0a040, user_data=0xbffffb68, error=0x00000000) + 240 at mono-config.c:176
    frame #5: 0x0040ba6d mtouch-32`monoeg_g_markup_parse_context_parse(context=0x00d09fa0, text=0x00b72f30, text_len=240, error=0x00000000) + 1965 at gmarkup.c:351
    frame #6: 0x002c0a93 mtouch-32`mono_config_parse_xml_with_context(state=0xbffffb68, text=0x00b72f30, len=240) + 147 at mono-config.c:440
    frame #7: 0x002c09eb mtouch-32`mono_config_parse_memory(buffer=0x00b72f30) + 123 at mono-config.c:482
    frame #8: 0x00001e6d mtouch-32`install_dll_config_files + 29
    frame #9: 0x00001c86 mtouch-32`mono_mkbundle_init + 22
    frame #10: 0x000029db mtouch-32`main + 331
    frame #11: 0x00001c65 mtouch-32`start + 53
```

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=24605.
2015-02-09 17:40:04 +00:00
Marek Safar 0daaf302a5 [corlib] Update failing test 2015-02-10 02:01:29 +10:00
Vlad Brezae bea7d8a600 [jit] Pass the aligned object size to the managed allocator. 2015-02-03 23:51:59 +00:00
Vlad Brezae 29659f7623 [jit] Optimize the managed allocator fastpath
Send the instance_size as an argument to the managed object allocator to reduce memory dereferences from the vtable in the generated code.
2015-02-03 23:51:58 +00:00
Dave Curylo 7cbeed36fd Fix to UriTemplate.Match to properly handle query parameters without a value. No longer throws IndexOutOfRangeException and the parameter is added to the resulting UriTemplateMatch.QueryParameters field with a null value, same as in .NET.
This change is released under the MIT license.
2015-01-31 07:21:03 -05:00
Henrik Feldt 789d43622e [crypto] Re-instantiate for Invariants() test 2015-01-28 17:13:02 +01:00
Henrik Feldt 0b8d94d285 [crypto] check key length in test 2015-01-28 16:51:11 +01:00
Henrik Feldt 7fc8c726ad [crypto] Key size 128 bytes for HMACSHA512
Using recommended key size according to MSDN (1) and RFC4868 (2).

 (1): https://msdn.microsoft.com/en-us/library/w5y83hkf%28v=vs.110%29.aspx
 (2): https://tools.ietf.org/html/rfc4868
2015-01-28 16:28:24 +01:00
Henrik Feldt c72f6c2fb5 [crypto] Key size 128 bytes for HMACSHA384
Using recommended key size according to MSDN (1) and RFC4868 (2).

 (1): https://msdn.microsoft.com/en-us/library/h43559cy%28v=vs.110%29.aspx
 (2): https://tools.ietf.org/html/rfc4868
2015-01-28 16:28:24 +01:00
Henrik Feldt ad4a6a5369 [crypto] Key size 64 for HMACSHA256
Using recommended key size according to MSDN (1) and RFC4868.

Fixes #23808 - https://bugzilla.xamarin.com/show_bug.cgi?id=23808

 (1): https://msdn.microsoft.com/en-us/library/9c9tf8wc%28v=vs.110%29.aspx
 (2): https://tools.ietf.org/html/rfc4868 - under
      2.1.1.  Data Origin Authentication and Integrity Verification Usage
2015-01-28 16:28:09 +01:00
Henrik Feldt f3d2c41b26 [crypto] Key size 64 for HMACSHA1
This HMAC cipher accepts any key size (1), took from RFC2104, which uses
the full 64 bytes of key since it has a block length of 64 bytes.

 (1): https://www.ietf.org/rfc/rfc2104.txt - Chapter 2: Definition of HMAC
2015-01-28 16:27:54 +01:00
Henrik Feldt 1caf94bec7 [crypto] Key size 64 for HMACRIPEMD160
This HMAC cipher accepts any key size (1), took 64 bytes from MSDN (2)

 (1): https://tools.ietf.org/html/rfc2857 - chapter 3 keying material
 (2): https://msdn.microsoft.com/en-us/library/8k00xhf0%28v=vs.110%29.aspx
2015-01-28 16:27:41 +01:00
Etienne CHAMPETIER 81057618ac System.Xml.Serialization: fix xml serializers generation for Web Services
(add a reference to System.Web.Services)

Without this patch we get the following exception after multiple call
to a soap web services:
Error while compiling generated serializer
/tmp/24ee1170/4996ddb2.cs(2519,27) : warning CS1522: Empty switch block
/tmp/24ee1170/4996ddb2.cs(969,29) : error CS0012: The type `System.Web.Services.Protocols.SoapHeader' is defined in an assembly that is not referenced. Consider adding a reference to assembly `System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'

Signed-off-by: Frederic Mestayer <[email protected]>
Signed-off-by: Etienne CHAMPETIER <[email protected]>
2015-01-09 15:02:10 +01:00
Alexander Köplinger 56ea776405 [xbuild] Only execute PCL target "ImplicitlyExpandTargetFramework" when corresponding property is true
This aligns xbuild with the MS.NET behavior.
2014-12-18 05:59:46 +01:00
600 changed files with 8656 additions and 60542 deletions

No files matched your search

+4
View File
@@ -109,6 +109,10 @@ GRTAGS
GSYMS
GTAGS
# Doxygen
docs/doxygen*
docs/perlmod*
##############################################################################
# Mono-specific patterns
+2 -5
View File
@@ -10,9 +10,6 @@
[submodule "external/debian-snapshot"]
path = external/debian-snapshot
url = git://github.com/directhex/mono-snapshot.git
[submodule "external/entityframework"]
path = external/entityframework
url = git://github.com/mono/entityframework.git
[submodule "external/rx"]
path = external/rx
url = git://github.com/mono/rx.git
@@ -29,7 +26,7 @@
[submodule "external/referencesource"]
path = external/referencesource
url = git://github.com/mono/referencesource
branch = mono
branch = mono-4.0.0-branch
[submodule "external/reference-assemblies"]
path = external/reference-assemblies
path = external/binary-reference-assemblies
url = git://github.com/mono/reference-assemblies.git
+1 -1
View File
@@ -52,7 +52,7 @@ dist-hook:
d=`cd $(distdir)/mcs && pwd`; cd $(mcs_topdir) && $(MAKE) distdir=$$d dist-recursive
rm -rf `find $(top_distdir)/external -path '*\.git'`
rm -f `find $(top_distdir)/external -path '*\.exe'`
rm -f `find $(top_distdir)/external -path '*\.dll' -not -path '*/reference-assemblies/v4\.0*'`
rm -f `find $(top_distdir)/external -path '*\.dll' -not -path '*/binary-reference-assemblies/*'`
cp mcs/class/lib/basic/System.Configuration.dll mcs/class/lib/monolite/
cp mcs/class/lib/basic/System.Security.dll mcs/class/lib/monolite/
# Disable this for now because it is very slow and causes wrench to timeout:
+26 -12
View File
@@ -1,7 +1,7 @@
# Process this file with autoconf to produce a configure script.
#AC_PREREQ([2.62])
AC_INIT(mono, [3.99.0],
AC_INIT(mono, [4.0.2],
[http://bugzilla.xamarin.com/enter_bug.cgi?classification=Mono])
AC_CONFIG_SRCDIR([README.md])
@@ -454,6 +454,8 @@ AC_CHECK_HEADERS(sys/user.h, [], [],
#endif
])
AC_CHECK_HEADERS(linux/serial.h)
AC_CHECK_HEADER(zlib.h, [have_zlib=yes], [have_zlib=no])
if test x$have_zlib = xyes; then
AC_TRY_COMPILE([#include <zlib.h>], [
@@ -526,26 +528,30 @@ AC_CACHE_CHECK([for clang],
[])
])
AC_ARG_ENABLE(visiblity-hidden,
[ --disable-visibility-hidden disable usage of -fvisiblity=hidden]
disable_visibility_hidden=no, disable_visibility_hidden=yes)
WARN=''
if test x"$GCC" = xyes; then
WARN='-Wall -Wunused -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Wpointer-arith -Wno-cast-qual -Wwrite-strings -Wno-switch -Wno-switch-enum -Wno-unused-value'
# We require C99 with some GNU extensions, e.g. `linux` macro
CFLAGS="$CFLAGS -std=gnu99"
# The runtime code does not respect ANSI C strict aliasing rules
CFLAGS="$CFLAGS -fno-strict-aliasing"
# We rely on signed overflow to behave
CFLAGS="$CFLAGS -fwrapv"
ORIG_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -Wdeclaration-after-statement"
AC_MSG_CHECKING(for -Wdeclaration-after-statement option to gcc)
AC_TRY_COMPILE([],[
return 0;
], [
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
CFLAGS=$ORIG_CFLAGS
])
CFLAGS="$CFLAGS -DMONO_DLL_EXPORT"
if test x"$disable_visibility_hidden" = xno; then
# Don't export any symbols by default
SHARED_CFLAGS="-fvisibility=hidden"
CFLAGS_FOR_EGLIB="$CFLAGS_FOR_EGLIB -fvisibility=hidden"
CXXFLAGS="$CXXFLAGS -fvisibility=hidden"
fi
ORIG_CFLAGS=$CFLAGS
# Check for the normal version, since gcc ignores unknown -Wno options
@@ -677,6 +683,7 @@ if test x$werror_flag = xyes; then
WERROR_CFLAGS="-Werror"
fi
AC_SUBST([WERROR_CFLAGS])
AC_SUBST([SHARED_CFLAGS])
ac_configure_args="$ac_configure_args \"CPPFLAGS_FOR_EGLIB=$EGLIB_CPPFLAGS\" \"CFLAGS_FOR_EGLIB=$CFLAGS_FOR_EGLIB\""
AC_CONFIG_SUBDIRS(eglib)
@@ -2514,6 +2521,12 @@ fi
AC_ARG_ENABLE(bcl-opt, [ --disable-bcl-opt BCL is compiled with no optimizations (allows accurate BCL debugging)], test_bcl_opt=$enableval, test_bcl_opt=yes)
AC_ARG_ENABLE(perf-events, [ --enable-perf-events Enable using `perf` for profiling on Linux], test_perf_events=$enableval, test_perf_events=no)
if test "x$test_perf_events" == "xyes"; then
AC_DEFINE(ENABLE_PERF_EVENTS, 1, [Enable using `perf` for profiling on Linux])
AC_SUBST(ENABLE_PERF_EVENTS)
fi
AC_MSG_CHECKING([if big-arrays are to be enabled])
AC_ARG_ENABLE(big-arrays, [ --enable-big-arrays Enable the allocation and indexing of arrays greater than Int32.MaxValue], enable_big_arrays=$enableval, enable_big_arrays=no)
if test "x$enable_big_arrays" = "xyes" ; then
@@ -3817,6 +3830,7 @@ AC_CONFIG_COMMANDS([runtime/etc/mono/4.5/web.config],
],[LN_S='$LN_S'])
AC_CONFIG_COMMANDS([quiet-libtool], [sed -e 's/echo "copying selected/# "copying selected/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool; sed -e 's/$ECHO "copying selected/# "copying selected/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool])
AC_CONFIG_COMMANDS([nolock-libtool], [sed -e 's/lock_old_archive_extraction=yes/lock_old_archive_extraction=no/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool])
AC_OUTPUT([
Makefile
+1 -1
View File
@@ -58,7 +58,7 @@ int mkstemp (char *tmp_template)
utf16_template = _wmktemp( utf16_template);
if (utf16_template && *utf16_template) {
/* FIXME: _O_TEMPORARY causes file to disappear on close causing a test to fail */
fd = _wopen( utf16_template, _O_BINARY | _O_CREAT /*| _O_TEMPORARY*/ | _O_EXCL, _S_IREAD | _S_IWRITE);
fd = _wopen( utf16_template, _O_BINARY | _O_CREAT /*| _O_TEMPORARY*/ | _O_RDWR | _O_EXCL, _S_IREAD | _S_IWRITE);
}
/* FIXME: this will crash if utf16_template == NULL */
+1
View File
@@ -132,6 +132,7 @@ g_assertion_message (const gchar *format, ...)
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
va_end (args);
exit (0);
}
+1 -1
View File
@@ -74,7 +74,7 @@
#define NO_INTR(var,cmd) do { (var) = (cmd); } while ((var) == -1 && errno == EINTR)
#define CLOSE_PIPE(p) do { close (p [0]); close (p [1]); } while (0)
#if defined(__APPLE__) && !defined (__arm__)
#if defined(__APPLE__) && !defined (__arm__) && !defined (__aarch64__)
/* Apple defines this in crt_externs.h but doesn't provide that header for
* arm-apple-darwin9. We'll manually define the symbol on Apple as it does
* in fact exist on all implementations (so far)
+1 -1
+1 -1
+4
View File
@@ -970,6 +970,10 @@ where V is the architecture number 4, 5, 6, 7 and the options can be currently b
.fi
.TP
\fBMONO_ARM_FORCE_SOFT_FLOAT\fR
When Mono is built with a soft float fallback on ARM and this variable is set to
"1", Mono will always emit soft float code, even if a VFP unit is detected.
.TP
\fBMONO_DISABLE_AIO\fR
If set, tells mono NOT to attempt using native asynchronous I/O services. In
that case, a default select/poll implementation is used. Currently only epoll()
+3 -3
View File
@@ -12,7 +12,7 @@ monotouch_runtime_SUBDIRS := build class
xammac_SUBDIRS := build class
mobile_SUBDIRS := build class
mobile_static_SUBDIRS := build class
net_4_0_SUBDIRS := build class
binary_reference_assemblies_SUBDIRS := build class
net_4_5_SUBDIRS := build mcs class nunit24 ilasm tools tests errors docs
xbuild_12_SUBDIRS := build class tools/xbuild
xbuild_14_SUBDIRS := build class tools/xbuild
@@ -30,7 +30,7 @@ dir-check:
# fun specialty targets
PROFILES = net_4_5 net_4_0 xbuild_12 xbuild_14
PROFILES = net_4_5 binary_reference_assemblies xbuild_12 xbuild_14
.PHONY: all-profiles $(STD_TARGETS:=-profiles)
all-profiles $(STD_TARGETS:=-profiles): %-profiles: profiles-do--%
@@ -51,7 +51,7 @@ profiles-do--run-test:
_boot_ = all clean install
$(_boot_:%=profile-do--xbuild_14--%): profile-do--xbuild_14--%: profile-do--net_4_5--%
$(_boot_:%=profile-do--xbuild_12--%): profile-do--xbuild_12--%: profile-do--net_4_5--%
$(_boot_:%=profile-do--net_4_0--%): profile-do--net_4_0--%: profile-do--build--%
$(_boot_:%=profile-do--binary_reference_assemblies--%): profile-do--binary_reference_assemblies--%: profile-do--build--%
$(_boot_:%=profile-do--net_4_5--%): profile-do--net_4_5--%: profile-do--build--%
$(_boot_:%=profile-do--monodroid--%): profile-do--monodroid--%: profile-do--build--%
$(_boot_:%=profile-do--monotouch--%): profile-do--monotouch--%: profile-do--build--%
+1 -1
View File
@@ -18,7 +18,7 @@ PLATFORMS = darwin linux win32
PROFILES = \
basic \
build \
net_4_0 \
binary_reference_assemblies \
net_4_5 \
xbuild_12 \
xbuild_14
+1 -1
View File
@@ -40,7 +40,7 @@ class X {
if (!Version.TryParse (field.GetValue (null) as string, out version))
return 4;
if (version < new Version (3, 2))
if (version < new Version (3, 8))
return 5;
return 0;
+6
View File
@@ -66,6 +66,12 @@ else
the_libdir_base = $(topdir)/class/$(lib_dir)/$(PROFILE)/
endif
ifdef RESOURCE_STRINGS
ifdef BOOTSTRAP_PROFILE
MCS_FLAGS_INTERNAL += $(RESOURCE_STRINGS:%=--getresourcestrings:%)
endif
endif
#
# The bare directory contains the plain versions of System and System.Xml
#
+1 -1
View File
@@ -65,7 +65,7 @@ do-profile-check: $(depsdir)/.stamp
$(MAKE) -s do-profile-check-monolite ; \
else \
echo "*** The compiler '$(BOOTSTRAP_MCS)' doesn't appear to be usable." 1>&2; \
echo "*** You need Mono version 3.2 or better installed to build MCS" 1>&2 ; \
echo "*** You need Mono version 3.8 or better installed to build MCS" 1>&2 ; \
echo "*** Check mono README for information on how to bootstrap a Mono installation." 1>&2 ; \
echo "*** The version of '$(BOOTSTRAP_MCS)' is: `$(BOOTSTRAP_MCS) --version`." 1>&2 ; \
exit 1; fi; fi
@@ -0,0 +1,7 @@
# -*- makefile -*-
profile-check:
@:
NO_BUILD = yes
NO_TEST = yes
-12
View File
@@ -1,12 +0,0 @@
# -*- makefile -*-
profile-check:
@:
FRAMEWORK_VERSION = 4.0
XBUILD_VERSION = 4.0
LIBRARY_INSTALL_DIR = $(mono_libdir)/mono/$(FRAMEWORK_VERSION)
NO_BUILD = yes
NO_TEST = yes
+1 -1
View File
@@ -28,7 +28,7 @@ ifndef BUILD_TOOLS_PROFILE
BUILD_TOOLS_PROFILE = build
endif
USE_MCS_FLAGS = /codepage:$(CODEPAGE) $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
USE_MCS_FLAGS = /codepage:$(CODEPAGE) $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS) $(MCS_FLAGS_INTERNAL)
USE_MBAS_FLAGS = /codepage:$(CODEPAGE) $(LOCAL_MBAS_FLAGS) $(PLATFORM_MBAS_FLAGS) $(PROFILE_MBAS_FLAGS) $(MBAS_FLAGS)
USE_CFLAGS = $(LOCAL_CFLAGS) $(CFLAGS) $(CPPFLAGS)
CSCOMPILE = $(Q_MCS) $(MCS) $(USE_MCS_FLAGS)
@@ -1,187 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{D1081004-B9C0-4982-BA68-EB5999440ACD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<OutputPath>./../../class/lib/net_4_5</OutputPath>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>EntityFramework.SqlServer</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../ecma.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>DEBUG;TRACE;NET_1_1;NET_2_0;NET_3_0;NET_3_5;NET_4_0;NET_4_5;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_1_1;NET_2_0;NET_3_0;NET_3_5;NET_4_0;NET_4_5;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\DbGeographyAdapter.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\DbGeometryAdapter.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\DefaultSqlExecutionStrategy.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Expressions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\GlobalSuppressions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\IDbSpatialValue.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\IDbSpatialValueExtensionMethods.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Properties\AssemblyVersion.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Properties\InternalsVisibleTo.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Properties\Resources.SqlServer.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlAzureDbConfiguration.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlAzureExecutionStrategy.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlAzureRetriableExceptionDetector.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlDdlBuilder.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlExecutionStrategyResolver.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\BoolWrapper.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\DmlSqlGenerator.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\ISqlFragment.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\JoinSymbol.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\OptionalColumn.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\Sql8ConformanceChecker.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\Sql8ExpressionRewriter.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlBuilder.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlFunctionCallHandler.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlGenerator.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlSelectClauseBuilder.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlSelectStatement.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SqlWriter.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\Symbol.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SymbolPair.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SymbolTable.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\SymbolUsageManager.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlGen\TopClause.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlProviderManifest.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlProviderServices.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlProviderUtilities.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlSpatialDataReader.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlSpatialServices.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlSpatialServicesForConversions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlTypesAssembly.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlTypesAssemblyLoader.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlVersion.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\SqlVersionUtils.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\Check.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\DbExpressionExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\DebugCheck.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\EdmFunctionExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\FuncExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\IDictionaryExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\MetdataItemExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\PrimitiveTypeExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\SqlDataReaderWrapper.cs" />
<Compile Include="..\..\..\external\entityframework\src\EntityFramework.SqlServer\Utilities\TypeUsageExtensions.cs" />
<Compile Include="..\..\..\external\entityframework\src\SharedAssemblyInfo.cs" />
<Compile Include="..\..\..\external\entityframework\src\SharedAssemblyVersionInfo.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../corlib/corlib-net_4_5.csproj">
<Project>{33BF0182-AC5C-464C-995B-C9CFE74E1A95}</Project>
<Name>corlib-net_4_5</Name>
</ProjectReference>
<ProjectReference Include="../System/System-net_4_5.csproj">
<Project>{FFAC0B73-D997-493B-9C62-27656CD858BB}</Project>
<Name>System-net_4_5</Name>
</ProjectReference>
<ProjectReference Include="../System.XML/System.Xml-net_4_5.csproj">
<Project>{2951DEC2-4393-4A78-83F9-42EB39CB708F}</Project>
<Name>System.Xml-net_4_5</Name>
</ProjectReference>
<ProjectReference Include="../System.Core/System.Core-net_4_5.csproj">
<Project>{D92530F4-3F2B-4351-BD21-9D6BEE6D2A4E}</Project>
<Name>System.Core-net_4_5</Name>
</ProjectReference>
<ProjectReference Include="../EntityFramework/EntityFramework-net_4_5.csproj">
<Project>{CEE31F03-087E-4164-BBD4-990759B40C3E}</Project>
<Name>EntityFramework-net_4_5</Name>
</ProjectReference>
<ProjectReference Include="../System.Data/System.Data-net_4_5.csproj">
<Project>{9A33954F-57A8-4D75-B1D8-0F81808A0DD4}</Project>
<Name>System.Data-net_4_5</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="System.Data.Entity.SqlServer.Properties.Resources.SqlServer.resources">
<LogicalName>System.Data.Entity.SqlServer.Properties.Resources.SqlServer.resources</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.ProviderManifest.xml">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.ProviderManifest.xml</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition.ssdl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition.ssdl</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition_Sql8.ssdl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition_Sql8.ssdl</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3.ssdl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3.ssdl</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3_Sql8.ssdl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3_Sql8.ssdl</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMapping.msl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMapping.msl</LogicalName>
</EmbeddedResource>
<EmbeddedResource Include="../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMappingVersion3.msl">
<LogicalName>System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMappingVersion3.msl</LogicalName>
</EmbeddedResource>
</ItemGroup>
</Project>
@@ -1,55 +0,0 @@
../../../external/entityframework/src/SharedAssemblyInfo.cs
../../../external/entityframework/src/SharedAssemblyVersionInfo.cs
../../../external/entityframework/src/EntityFramework.SqlServer/DbGeographyAdapter.cs
../../../external/entityframework/src/EntityFramework.SqlServer/DbGeometryAdapter.cs
../../../external/entityframework/src/EntityFramework.SqlServer/DefaultSqlExecutionStrategy.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Expressions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/GlobalSuppressions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/IDbSpatialValue.cs
../../../external/entityframework/src/EntityFramework.SqlServer/IDbSpatialValueExtensionMethods.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Properties/AssemblyVersion.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Properties/InternalsVisibleTo.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Properties/Resources.SqlServer.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlAzureDbConfiguration.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlAzureExecutionStrategy.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlAzureRetriableExceptionDetector.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlDdlBuilder.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlExecutionStrategyResolver.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/BoolWrapper.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/DmlSqlGenerator.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlSpatialServicesForConversions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlTypesAssemblyLoader.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlVersionUtils.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/Check.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/SqlDataReaderWrapper.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/DbExpressionExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/DebugCheck.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/EdmFunctionExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/MetdataItemExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/FuncExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/IDictionaryExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/ISqlFragment.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/JoinSymbol.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/OptionalColumn.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/Sql8ConformanceChecker.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/Sql8ExpressionRewriter.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlBuilder.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlFunctionCallHandler.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlGenerator.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlSelectClauseBuilder.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlSelectStatement.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SqlWriter.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/Symbol.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SymbolPair.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SymbolTable.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/SymbolUsageManager.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlGen/TopClause.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlProviderManifest.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlProviderServices.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlProviderUtilities.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlSpatialDataReader.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlSpatialServices.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlTypesAssembly.cs
../../../external/entityframework/src/EntityFramework.SqlServer/SqlVersion.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/PrimitiveTypeExtensions.cs
../../../external/entityframework/src/EntityFramework.SqlServer/Utilities/TypeUsageExtensions.cs
@@ -1,28 +0,0 @@
thisdir = class/EntityFramework.SqlServer
SUBDIRS =
include ../../build/rules.make
LIBRARY = EntityFramework.SqlServer.dll
System.Data.Entity.SqlServer.Properties.Resources.SqlServer.resources: ../../../external/entityframework/src/EntityFramework.SqlServer/Properties/Resources.SqlServer.resx
$(RESGEN) "$<" "$@"
RESOURCES = \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.ProviderManifest.xml \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition.ssdl \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinition_Sql8.ssdl \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3.ssdl \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaDefinitionVersion3_Sql8.ssdl \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMapping.msl \
../../../external/entityframework/src/EntityFramework.SqlServer/Resources/System/Data/SqlClient/System.Data.Resources.SqlClient.SqlProviderServices.StoreSchemaMappingVersion3.msl
LIB_MCS_FLAGS = -r:System.dll -r:System.Xml.dll -r:System.Core.dll -r:EntityFramework.dll -r:System.Data.dll \
-keyfile:../ecma.pub -delaysign -warn:1 \
-resource:System.Data.Entity.SqlServer.Properties.Resources.SqlServer.resources \
$(RESOURCES:%=-resource:%)
include ../../build/library.make
$(the_lib): System.Data.Entity.SqlServer.Properties.Resources.SqlServer.resources
-1
View File
@@ -1 +0,0 @@
System.Data.Resources.EntityStoreSchemaGenerator.xsd
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
-50
View File
@@ -1,50 +0,0 @@
thisdir = class/EntityFramework
SUBDIRS =
include ../../build/rules.make
LIBRARY = EntityFramework.dll
System.Data.Entity.Properties.Resources.resources: ../../../external/entityframework/src/EntityFramework/Properties/Resources.resx
$(RESGEN) "$<" "$@"
System.Data.Entity.Properties.Resources.Migrate.resources: ../../../external/entityframework/src/EntityFramework/Properties/Resources.Migrate.resx
$(RESGEN) "$<" "$@"
System.Data.Entity.Properties.Resources.PowerShell.resources: ../../../external/entityframework/src/EntityFramework/Properties/Resources.PowerShell.resx
$(RESGEN) "$<" "$@"
RESOURCES = ../../../external/entityframework/src/EntityFramework/Resources/System/Data/System.Data.Resources.DbProviderServices.ConceptualSchemaDefinition.csdl \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/System.Data.Resources.DbProviderServices.ConceptualSchemaDefinitionVersion3.csdl \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/System.Data.Resources.ProviderServices.ProviderManifest.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.AnnotationSchema.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.CodeGenerationSchema.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.CSDLSchema_1.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.CSDLSchema_1_1.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.CSDLSchema_2.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.CSDLSchema_3.xsd \
System.Data.Resources.EntityStoreSchemaGenerator.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.SSDLSchema.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.SSDLSchema_2.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/System.Data.Resources.SSDLSchema_3.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/MappingSpecification/System.Data.Resources.CSMSL_1.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/MappingSpecification/System.Data.Resources.CSMSL_2.xsd \
../../../external/entityframework/src/EntityFramework/Resources/System/Data/MappingSpecification/System.Data.Resources.CSMSL_3.xsd
LIB_MCS_FLAGS = -r:System.Data.dll -r:System.Transactions.dll -r:System.Xml.Linq.dll -r:System.Configuration.dll -r:System.ComponentModel.DataAnnotations.dll -r:System.Runtime.Serialization.dll \
-r:System.dll -r:System.Xml.dll -r:System.Core.dll -r:Microsoft.CSharp.dll -keyfile:../ecma.pub -delaysign -warn:1 \
-resource:System.Data.Entity.Properties.Resources.resources \
-resource:System.Data.Entity.Properties.Resources.Migrate.resources \
-resource:System.Data.Entity.Properties.Resources.PowerShell.resources \
$(RESOURCES:%=-resource:%)
CLEAN_FILES = System.Data.Resources.EntityStoreSchemaGenerator.xsd
System.Data.Resources.EntityStoreSchemaGenerator.xsd:
cp ../../../external/entityframework/src/EntityFramework/Resources/System/Data/EntityModel/system.data.resources.entitystoreschemagenerator.xsd System.Data.Resources.EntityStoreSchemaGenerator.xsd
include ../../build/library.make
$(the_lib): System.Data.Resources.EntityStoreSchemaGenerator.xsd \
System.Data.Entity.Properties.Resources.resources \
System.Data.Entity.Properties.Resources.Migrate.resources \
System.Data.Entity.Properties.Resources.PowerShell.resources
@@ -20,10 +20,6 @@
// THE SOFTWARE.
//
#if !MONOTOUCH
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.CompressionFormat))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Dispatcher.ClientOperation))]
#endif
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.ActionNotSupportedException))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.ChannelFactory))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.ChannelFactory<>))]
@@ -44,6 +40,7 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.ChannelManagerBase))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.ChannelParameterCollection))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.CommunicationObject))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.CompressionFormat))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.CustomBinding))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.FaultConverter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Channels.IChannel))]
@@ -105,6 +102,7 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Description.OperationDescription))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Description.OperationDescriptionCollection))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Description.ServiceEndpoint))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Dispatcher.ClientOperation))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Dispatcher.ClientRuntime))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Dispatcher.DispatchOperation))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ServiceModel.Dispatcher.DispatchRuntime))]
+8
View File
@@ -712,6 +712,14 @@ namespace I18N.CJK
public override int WindowsCodePage {
get { return SHIFTJIS_CODE_PAGE; }
}
// FIXME: This doesn't make sense, but without declaring this override
// System.XML regresses at Encoder.Convert() in
// MonoTests.System.Xml.XmlWriterSettingsTests.EncodingTest.
public override Encoder GetEncoder ()
{
return new MonoEncodingDefaultEncoder (this);
}
}; // class CP932
+148
View File
@@ -0,0 +1,148 @@
// This is partially copied source from referencesource/mscorlib/system/text/encoding.cs, modifying a bit.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
using System;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Text;
namespace I18N.Common
{
[Serializable]
public class ReferenceSourceDefaultEncoder : Encoder, IObjectReference
{
private Encoding m_encoding;
[NonSerialized] private bool m_hasInitializedEncoding;
[NonSerialized] internal char charLeftOver;
public ReferenceSourceDefaultEncoder(Encoding encoding)
{
m_encoding = encoding;
m_hasInitializedEncoding = true;
}
// Constructor called by serialization, have to handle deserializing from Everett
internal ReferenceSourceDefaultEncoder(SerializationInfo info, StreamingContext context)
{
if (info==null) throw new ArgumentNullException("info");
Contract.EndContractBlock();
// All we have is our encoding
this.m_encoding = (Encoding)info.GetValue("encoding", typeof(Encoding));
try
{
//this.m_fallback = (EncoderFallback) info.GetValue("m_fallback", typeof(EncoderFallback));
this.charLeftOver = (Char) info.GetValue("charLeftOver", typeof(Char));
}
catch (SerializationException)
{
}
}
// Just get it from GetEncoding
[System.Security.SecurityCritical] // auto-generated
public Object GetRealObject(StreamingContext context)
{
// upon deserialization since the DefaultEncoder implement IObjectReference the
// serialization code tries to do the fixup. The fixup returns another
// IObjectReference (the DefaultEncoder) class and hence so on and on.
// Finally the deserialization logics fails after following maximum references
// unless we short circuit with the following
if (m_hasInitializedEncoding)
{
return this;
}
Encoder encoder = m_encoding.GetEncoder();
/*
if (m_fallback != null)
encoder.m_fallback = m_fallback;
if (charLeftOver != (char) 0)
{
EncoderNLS encoderNls = encoder as EncoderNLS;
if (encoderNls != null)
encoderNls.charLeftOver = charLeftOver;
}
*/
return encoder;
}
#if FEATURE_SERIALIZATION
// ISerializable implementation, get data for this object
[System.Security.SecurityCritical] // auto-generated_required
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
// Any info?
if (info==null) throw new ArgumentNullException("info");
Contract.EndContractBlock();
// All we have is our encoding
info.AddValue("encoding", this.m_encoding);
}
#endif
// Returns the number of bytes the next call to GetBytes will
// produce if presented with the given range of characters and the given
// value of the flush parameter. The returned value takes into
// account the state in which the encoder was left following the last call
// to GetBytes. The state of the encoder is not affected by a call
// to this method.
//
public override int GetByteCount(char[] chars, int index, int count, bool flush)
{
return m_encoding.GetByteCount(chars, index, count);
}
[System.Security.SecurityCritical] // auto-generated
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
public unsafe override int GetByteCount(char* chars, int count, bool flush)
{
return m_encoding.GetByteCount(chars, count);
}
// Encodes a range of characters in a character array into a range of bytes
// in a byte array. The method encodes charCount characters from
// chars starting at index charIndex, storing the resulting
// bytes in bytes starting at index byteIndex. The encoding
// takes into account the state in which the encoder was left following the
// last call to this method. The flush parameter indicates whether
// the encoder should flush any shift-states and partial characters at the
// end of the conversion. To ensure correct termination of a sequence of
// blocks of encoded bytes, the last call to GetBytes should specify
// a value of true for the flush parameter.
//
// An exception occurs if the byte array is not large enough to hold the
// complete encoding of the characters. The GetByteCount method can
// be used to determine the exact number of bytes that will be produced for
// a given range of characters. Alternatively, the GetMaxByteCount
// method of the Encoding that produced this encoder can be used to
// determine the maximum number of bytes that will be produced for a given
// number of characters, regardless of the actual character values.
//
public override int GetBytes(char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex, bool flush)
{
return m_encoding.GetBytes(chars, charIndex, charCount, bytes, byteIndex);
}
[System.Security.SecurityCritical] // auto-generated
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
public unsafe override int GetBytes(char* chars, int charCount,
byte* bytes, int byteCount, bool flush)
{
return m_encoding.GetBytes(chars, charCount, bytes, byteCount);
}
}
}
+1
View File
@@ -6,4 +6,5 @@ Handlers.cs
Manager.cs
MonoEncoding.cs
MonoSafeEncoding.cs
DefaultEncoder.cs
Strings.cs
+77
View File
@@ -210,6 +210,11 @@ namespace I18N.Common
//[CLSCompliant (false)]
public unsafe abstract int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount);
public override Encoder GetEncoder ()
{
return new MonoEncodingDefaultEncoder (this);
}
}
public abstract class MonoEncoder : Encoder
@@ -304,4 +309,76 @@ namespace I18N.Common
bytes, ref byteIndex, ref byteCount, null);
}*/
}
public class MonoEncodingDefaultEncoder : ReferenceSourceDefaultEncoder
{
public MonoEncodingDefaultEncoder (Encoding encoding)
: base (encoding)
{
}
[CLSCompliant (false)]
[ComVisible (false)]
public unsafe override void Convert (
char* chars, int charCount,
byte* bytes, int byteCount, bool flush,
out int charsUsed, out int bytesUsed, out bool completed)
{
CheckArguments (chars, charCount, bytes, byteCount);
charsUsed = charCount;
while (true) {
bytesUsed = GetByteCount (chars, charsUsed, flush);
if (bytesUsed <= byteCount)
break;
flush = false;
charsUsed >>= 1;
}
completed = charsUsed == charCount;
bytesUsed = GetBytes (chars, charsUsed, bytes, byteCount, flush);
}
[ComVisible (false)]
public override void Convert (
char [] chars, int charIndex, int charCount,
byte [] bytes, int byteIndex, int byteCount, bool flush,
out int charsUsed, out int bytesUsed, out bool completed)
{
if (chars == null)
throw new ArgumentNullException ("chars");
if (bytes == null)
throw new ArgumentNullException ("bytes");
if (charIndex < 0)
throw new ArgumentOutOfRangeException ("charIndex");
if (charCount < 0 || chars.Length < charIndex + charCount)
throw new ArgumentOutOfRangeException ("charCount");
if (byteIndex < 0)
throw new ArgumentOutOfRangeException ("byteIndex");
if (byteCount < 0 || bytes.Length < byteIndex + byteCount)
throw new ArgumentOutOfRangeException ("byteCount");
charsUsed = charCount;
while (true) {
bytesUsed = GetByteCount (chars, charIndex, charsUsed, flush);
if (bytesUsed <= byteCount)
break;
flush = false;
charsUsed >>= 1;
}
completed = charsUsed == charCount;
bytesUsed = GetBytes (chars, charIndex, charsUsed, bytes, byteIndex, flush);
}
unsafe void CheckArguments (char* chars, int charCount, byte* bytes, int byteCount)
{
if (chars == null)
throw new ArgumentNullException ("chars");
if (bytes == null)
throw new ArgumentNullException ("bytes");
if (charCount < 0)
throw new ArgumentOutOfRangeException ("charCount");
if (byteCount < 0)
throw new ArgumentOutOfRangeException ("byteCount");
}
}
}
+1 -4
View File
@@ -108,7 +108,6 @@ net_4_5_dirs := \
Microsoft.VisualC \
Cscompmgd \
PEAPI \
Npgsql \
Commons.Xml.Relaxng \
Novell.Directory.Ldap \
Mono.Security.Win32 \
@@ -194,8 +193,6 @@ net_4_5_dirs := \
System.Web.Http \
System.Web.Http.SelfHost \
System.Web.Http.WebHost \
EntityFramework \
EntityFramework.SqlServer \
Mono.CodeContracts \
System.IO.Compression \
System.IO.Compression.FileSystem \
@@ -220,7 +217,7 @@ monotouch_runtime_SUBDIRS := $(monotouch_runtime_dirs)
mobile_static_SUBDIRS := $(mobile_static_dirs)
mobile_SUBDIRS := $(mobile_dynamic_dirs)
xammac_SUBDIRS := $(xammac_dirs)
net_4_0_SUBDIRS := reference-assemblies
binary_reference_assemblies_SUBDIRS := reference-assemblies
net_4_5_SUBDIRS := $(net_4_5_dirs) $(xbuild_4_0_dirs) aot-compiler
xbuild_12_SUBDIRS := $(xbuild_4_0_dirs)
xbuild_14_SUBDIRS := $(xbuild_4_0_dirs)
@@ -38,10 +38,8 @@ namespace System.Windows.Forms {
void CreateEditingControl ()
{
editingControl = new DataGridViewTextBoxEditingControl() {
EditingControlDataGridView = DataGridView,
Multiline = false,
BorderStyle = BorderStyle.None,
MaxLength = maxInputLength
BorderStyle = BorderStyle.None
};
}
@@ -92,8 +90,13 @@ namespace System.Windows.Forms {
throw new InvalidOperationException("There is no associated DataGridView.");
}
CreateEditingControl ();
if (editingControl == null)
CreateEditingControl ();
DataGridView.EditingControlInternal = editingControl;
editingControl.EditingControlDataGridView = DataGridView;
editingControl.MaxLength = maxInputLength;
if (initialFormattedValue == null || initialFormattedValue.ToString () == string.Empty)
editingControl.Text = string.Empty;
@@ -126,6 +129,9 @@ namespace System.Windows.Forms {
public override void PositionEditingControl (bool setLocation, bool setSize, Rectangle cellBounds, Rectangle cellClip, DataGridViewCellStyle cellStyle, bool singleVerticalBorderAdded, bool singleHorizontalBorderAdded, bool isFirstDisplayedColumn, bool isFirstDisplayedRow)
{
if (editingControl == null)
CreateEditingControl ();
cellBounds.Size = new Size (cellBounds.Width - 5, cellBounds.Height + 2);
cellBounds.Location = new Point (cellBounds.X + 3, ((cellBounds.Height - editingControl.Height) / 2) + cellBounds.Y - 1);
@@ -1775,7 +1775,8 @@ namespace System.Windows.Forms
switch (met) {
case ToolStripItemEventType.MouseUp:
this.HandleClick (((MouseEventArgs)e).Clicks, e);
if (((MouseEventArgs)e).Button == MouseButtons.Left)
this.HandleClick (((MouseEventArgs)e).Clicks, e);
this.OnMouseUp ((MouseEventArgs)e);
break;
case ToolStripItemEventType.MouseDown:
@@ -152,6 +152,15 @@ namespace Microsoft.Build.BuildEngine {
project_attribute.IndexOf ("$(MSBuildExtensionsPath32)") >= 0 ||
project_attribute.IndexOf ("$(MSBuildExtensionsPath64)") >= 0;
bool condn_has_extn_ref = condition_attribute.IndexOf ("$(MSBuildExtensionsPath)") >= 0 ||
condition_attribute.IndexOf ("$(MSBuildExtensionsPath32)") >= 0 ||
condition_attribute.IndexOf ("$(MSBuildExtensionsPath64)") >= 0;
// we can skip the following logic in case the condition doesn't reference any extension paths
// and it evaluates to false since nothing would change anyway
if (!condn_has_extn_ref && !ConditionParser.ParseAndEvaluate (condition_attribute, project))
return;
string importingFile = importingProject != null ? importingProject.FullFileName : project.FullFileName;
DirectoryInfo base_dir_info = null;
if (!String.IsNullOrEmpty (importingFile))
@@ -150,7 +150,18 @@ namespace Microsoft.Build.BuildEngine
public static string MakeRelative (string basePath, string path)
{
throw new NotImplementedException ("MakeRelative");
if (String.IsNullOrEmpty (basePath))
return path;
// ensure trailing slash for basePath
if (basePath [basePath.Length - 1] != '\\' && basePath [basePath.Length - 1] != '/')
basePath += '/';
var uriBasePath = new Uri (basePath, UriKind.Absolute);
var uriPath = new Uri (path);
var uriRelative = uriBasePath.MakeRelativeUri (uriPath);
return Uri.UnescapeDataString (uriRelative.ToString ()).Replace ('/', '\\'); // msbuild uses backslash paths everywhere
}
public static string ValueOrDefault (string value, string defaultValue)
@@ -14,6 +14,7 @@ Microsoft.Build.BuildEngine/ImportTest.cs
Microsoft.Build.BuildEngine/InternalLoggerExceptionTest.cs
Microsoft.Build.BuildEngine/InvalidProjectFileExceptionTest.cs
Microsoft.Build.BuildEngine/ProjectTest.cs
Microsoft.Build.BuildEngine/PredefinedPropertyFunctionsTest.cs
Microsoft.Build.BuildEngine/TargetCollectionTest.cs
Microsoft.Build.BuildEngine/TargetTest.cs
Microsoft.Build.BuildEngine/TestNamespaceManager.cs
@@ -209,7 +209,38 @@ namespace MonoTests.Microsoft.Build.BuildEngine {
project.LoadXml (documentString);
}
#if NET_4_0
[Test]
public void TestImportEmptyVariableWithConditionFalse ()
{
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Import Project='$(ImportPath)' Condition='false' />
<Target Name='Build' />
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.IsTrue (project.Build ("Build"), "Build failed");
}
[Test]
public void TestImportProjectWithConditionReferencingExtensionPath ()
{
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Import Project='$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets' Condition=""Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets')"" />
<Target Name='Build' />
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.IsTrue (project.Build ("Build"), "Build failed");
}
[Test]
public void TestImportWildcard ()
{
@@ -264,7 +295,6 @@ namespace MonoTests.Microsoft.Build.BuildEngine {
File.Delete (second_project);
}
}
#endif
}
}
@@ -0,0 +1,78 @@
//
// PredefinedPropertyFunctionsTest.cs
//
// Authors:
// Alexander Köplinger ([email protected])
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using Microsoft.Build.BuildEngine;
using NUnit.Framework;
namespace MonoTests.Microsoft.Build.BuildEngine {
[TestFixture]
public class PredefinedPropertyFunctionsTest {
[Test]
public void TestMakeRelative ()
{
string documentString = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<Path1>c:\users\</Path1>
<Path2>c:\users\username\</Path2>
<Path3>/home/user/</Path3>
<Path4>/home/user/username/</Path4>
<Path5>/home/user/</Path5>
<Path6>/tmp/test/file</Path6>
<Path7>/home/user/</Path7>
<Path8>/home/user/username/path with spaces + special? chars (1)/</Path8>
<Path9>c:\users</Path9>
<Path10>c:\users\username\test\</Path10>
<Path11>/home/user</Path11>
<Path12>/home/user/username/test/</Path12>
<MakeRelative1>$([MSBuild]::MakeRelative($(Path1), $(Path2)))</MakeRelative1>
<MakeRelative2>$([MSBuild]::MakeRelative($(Path2), $(Path1)))</MakeRelative2>
<MakeRelative3>$([MSBuild]::MakeRelative($(Path3), $(Path4)))</MakeRelative3>
<MakeRelative4>$([MSBuild]::MakeRelative($(Path4), $(Path3)))</MakeRelative4>
<MakeRelative5>$([MSBuild]::MakeRelative($(Path5), $(Path6)))</MakeRelative5>
<MakeRelative6>$([MSBuild]::MakeRelative($(Path7), $(Path8)))</MakeRelative6>
<MakeRelative7>$([MSBuild]::MakeRelative($(Path9), $(Path10)))</MakeRelative7>
<MakeRelative8>$([MSBuild]::MakeRelative($(Path11), $(Path12)))</MakeRelative8>
</PropertyGroup>
</Project>
";
var engine = new Engine (Consts.BinPath);
var project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.AreEqual (@"username\", project.EvaluatedProperties ["MakeRelative1"].FinalValue, "#1");
Assert.AreEqual (@"..\", project.EvaluatedProperties ["MakeRelative2"].FinalValue, "#2");
Assert.AreEqual (@"username\", project.EvaluatedProperties ["MakeRelative3"].FinalValue, "#3");
Assert.AreEqual (@"..\", project.EvaluatedProperties ["MakeRelative4"].FinalValue, "#4");
Assert.AreEqual (@"..\..\tmp\test\file", project.EvaluatedProperties ["MakeRelative5"].FinalValue, "#5");
Assert.AreEqual (@"username\path with spaces + special? chars (1)\", project.EvaluatedProperties ["MakeRelative6"].FinalValue, "#6");
Assert.AreEqual (@"username\test\", project.EvaluatedProperties ["MakeRelative7"].FinalValue, "#7");
Assert.AreEqual (@"username\test\", project.EvaluatedProperties ["MakeRelative8"].FinalValue, "#8");
}
}
}
@@ -256,9 +256,8 @@ namespace Microsoft.Build.Tasks {
{
PackageAssemblyInfo pkg = null;
if (specific_version) {
pkg = PcCache.GetAssemblyLocation (reference.ItemSpec);
} else {
pkg = PcCache.GetAssemblyLocation (reference.ItemSpec);
if (pkg == null && !specific_version) {
// if not specific version, then just match simple name
string name = reference.ItemSpec;
if (name.IndexOf (',') > 0)
@@ -29,6 +29,7 @@ using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
@@ -41,7 +42,10 @@ namespace Microsoft.Build.Tasks {
bool skipUnchangedFiles;
ITaskItem[] sourceFiles;
bool overwriteReadOnlyFiles;
int retries;
int retryDelayMilliseconds;
bool useHardlinksIfPossible;
public Copy ()
{
}
@@ -79,7 +83,7 @@ namespace Microsoft.Build.Tasks {
}
if (!skipUnchangedFiles || HasFileChanged (sourceFile, destinationFile))
CopyFile (sourceFile, destinationFile, true);
CopyFileWithRetries (sourceFile, destinationFile, true);
sourceItem.CopyMetadataTo (destinationItem);
temporaryCopiedFiles.Add (destinationItem);
@@ -102,7 +106,7 @@ namespace Microsoft.Build.Tasks {
if (!skipUnchangedFiles || directoryCreated ||
HasFileChanged (sourceFile, destinationFile))
CopyFile (sourceFile, destinationFile, false);
CopyFileWithRetries (sourceFile, destinationFile, false);
temporaryCopiedFiles.Add (new TaskItem (
Path.Combine (destinationFolder.GetMetadata ("Identity"), filename),
@@ -172,6 +176,34 @@ namespace Microsoft.Build.Tasks {
}
}
public int Retries {
get {
return retries;
}
set {
retries = value;
}
}
public int RetryDelayMilliseconds {
get {
return retryDelayMilliseconds;
}
set {
retryDelayMilliseconds = value;
}
}
[MonoTODO ("Not implemented yet.")]
public bool UseHardlinksIfPossible {
get {
return useHardlinksIfPossible;
}
set {
useHardlinksIfPossible = value;
}
}
[Required]
public ITaskItem[] SourceFiles {
get {
@@ -193,6 +225,23 @@ namespace Microsoft.Build.Tasks {
return true;
}
void CopyFileWithRetries (string source, string dest, bool create_dir)
{
for (int i = retries; i >= 0; i--) {
try {
CopyFile (source, dest, create_dir);
}
catch (Exception ex) {
Log.LogMessage ("Copying failed. Retries left: {0}.", i);
if (i == 0)
throw;
Thread.Sleep (retryDelayMilliseconds);
}
}
}
void CopyFile (string source, string dest, bool create_dir)
{
if (create_dir)
@@ -73,6 +73,8 @@ namespace Microsoft.Build.Tasks {
commandLine.AppendSwitchIfNotNull ("/main:", MainEntryPoint);
// NoStandardLib
if (Bag ["NoStandardLib"] != null && NoStandardLib)
commandLine.AppendSwitch ("/nostdlib");
if (NoWarnings)
commandLine.AppendSwitch ("/nowarn");
@@ -30,6 +30,7 @@ using System.IO;
using Microsoft.Build.BuildEngine;
using NUnit.Framework;
using System.Text;
using System.Threading;
using Microsoft.Build.Tasks;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
@@ -396,6 +397,61 @@ namespace MonoTests.Microsoft.Build.Tasks {
File.SetAttributes (target_file, FileAttributes.Normal);
}
[Test]
public void TestCopy_Retries ()
{
Engine engine;
Project project;
string file_path = Path.Combine (source_path, "copyretries.txt");
string target_file = Path.Combine (target_path, "copyretries.txt");
using (File.CreateText (file_path)) { }
using (File.CreateText (target_file)) { }
File.SetAttributes (target_file, FileAttributes.ReadOnly);
Assert.AreEqual (FileAttributes.ReadOnly, File.GetAttributes (target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' Retries='3' RetryDelayMilliseconds='2000'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
// remove the read-only flag from the file after a few secs,
// so copying works after retries
new Thread ( () => {
Thread.Sleep (3000);
File.SetAttributes (target_file, FileAttributes.Normal);
}).Start ();
if (!project.Build ("1")) {
var sb = new StringBuilder ();
testLogger.DumpMessages (sb);
Assert.Fail ("Build failed " + sb.ToString ());
}
testLogger.CheckLoggedAny ("Copying failed. Retries left: 3.", MessageImportance.Normal, "A2");
}
void CheckCopyBuildItems (Project project, string [] source_files, string destination_folder, string prefix)
{
int num = source_files.Length;
@@ -155,7 +155,6 @@ namespace MonoTests.EvaluatorTest
Assert.AreEqual (124, res);
}
#if NET_4_0
[Test]
public void DynamicStatement ()
{
@@ -163,9 +162,7 @@ namespace MonoTests.EvaluatorTest
Evaluator.Run ("d = 'a';");
Evaluator.Run ("d.GetType ();");
}
#endif
#if NET_4_5
[Test]
public void AwaitExpression ()
{
@@ -174,6 +171,14 @@ namespace MonoTests.EvaluatorTest
res = Evaluator.Evaluate ("res;");
Assert.AreEqual (3, res, "#1");
}
#endif
[Test]
public void UsingStatic ()
{
Evaluator.Run ("using static System.String;");
var res = Evaluator.Evaluate("Join (\"--\", new [] { \"a\", \"b\" } );");
Assert.AreEqual ("a--b", res);
}
}
}
@@ -5,4 +5,5 @@ SqliteDataReaderTest.cs
SqliteExceptionUnitTests.cs
SqliteParameterUnitTests.cs
SqliteFunctionTests.cs
Bug27864.cs
+110
View File
@@ -0,0 +1,110 @@
//
// Unit test for bug https://bugzilla.xamarin.com/show_bug.cgi?id=27864
//
// Authors:
// Thomas Zoechling <[email protected]>
// Alex Soto <[email protected]>
//
//
// Copyright 2015 Xamarin Inc.
//
#if MONOTOUCH
using System;
using System.Data;
using System.IO;
using System.Text;
using Mono.Data.Sqlite;
using NUnit.Framework;
namespace MonoTests.Mono.Data.Sqlite {
[TestFixture]
public class SqliteiOS82BugTests {
readonly static string dbPath = Path.Combine (Environment.GetFolderPath (Environment.SpecialFolder.Personal), "adodemo.db3");
readonly static string connectionString = "Data Source=" + dbPath;
static SqliteConnection cnn = new SqliteConnection (connectionString);
[SetUp]
public void Create()
{
try {
if(File.Exists(dbPath)) {
cnn.Dispose();
// We want to start with a fresh db for each full run
// The database is created on the first open()
File.Delete(dbPath);
}
}
catch(Exception e) {
throw e;
}
try {
using (var createCommand = new SqliteCommand ("CREATE TABLE Company (RecordId int, Name text);", cnn))
using (var insertCommand = new SqliteCommand ("INSERT INTO Company VALUES (1, 'Test CO')", cnn)) {
cnn.Open();
createCommand.ExecuteNonQuery();
insertCommand.ExecuteNonQuery();
}
}
catch(Exception e) {
Console.WriteLine (e);
throw new AssertionException ("Create table failed", e);
}
finally {
cnn.Close();
}
}
// Ref: https://bugzilla.xamarin.com/show_bug.cgi?id=27864
// As of iOS 8.2 Apple updated Sqlite and broke queries that used to work pre iOS 8.2 like the select command in this test
// The pruppose of this test is to know when apple fixes this. Expected test behaivour is as follows.
// If iOS 8.2+ Test will pass as long as apple does not fix the bug
// If iOS < 8.2 Test will pass as it does work as expected
// If iOS 8.2+ and apple fixed bug 27864 test will fail and we will need to remove the fail check on lines 105 and 106
[Test]
public void SqliteSelectTestBug27864()
{
try {
var cmdText = "SELECT " +
"2 AS SortOrder, " +
"com.Name AS 'Company.Name' " +
"FROM " +
"company com " +
"UNION " +
"SELECT " +
"0 AS SortOrder, " +
"com.Name AS 'Company.Name' " +
"FROM " +
"Company com " +
"ORDER BY " +
"com.Name, " +
"SortOrder COLLATE NOCASE";
using (cnn)
using (var cmd = new SqliteCommand (cmdText, cnn)) {
cnn.Open();
using (SqliteDataReader dr = cmd.ExecuteReader()) {
var i = 0;
while (dr.Read()) {
Assert.AreEqual(dr["SortOrder"], i);
Assert.AreEqual(dr["Company.Name"], "Test CO");
i += 2;
}
Assert.IsTrue(dr.FieldCount>0);
}
if (BCL.Tests.TestRuntime.CheckSystemVersion (8, 2))
Assert.IsTrue (false, "Apple fixed bug 27864, this check can now be removed");
}
} catch (SqliteException ex) {
if (BCL.Tests.TestRuntime.CheckSystemVersion (8, 2)) // Expected Exception on iOS 8.2+, if this does not happen anymore it means apple fixed it
Assert.That (ex.Message.Contains ("no such column: com.Name"));
else
throw new AssertionException ("Unexpected Sqlite Error", ex); // This should not happen
}
}
}
}
#endif
@@ -116,14 +116,14 @@ namespace Mono.Security.Protocol.Tls
scs.Add((0x00 << 0x08) | 0x09, "TLS_RSA_WITH_DES_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, false, true, 8, 8, 56, 8, 8);
// Supported exportable ciphers
scs.Add((0x00 << 0x08) | 0x03, "TLS_RSA_EXPORT_WITH_RC4_40_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 5, 16, 40, 0, 0);
scs.Add((0x00 << 0x08) | 0x06, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 16, 40, 8, 8);
scs.Add((0x00 << 0x08) | 0x08, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 8, 40, 8, 8);
scs.Add((0x00 << 0x08) | 0x60, "TLS_RSA_EXPORT_WITH_RC4_56_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
scs.Add((0x00 << 0x08) | 0x61, "TLS_RSA_EXPORT_WITH_RC2_CBC_56_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 7, 16, 56, 8, 8);
// scs.Add((0x00 << 0x08) | 0x03, "TLS_RSA_EXPORT_WITH_RC4_40_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 5, 16, 40, 0, 0);
// scs.Add((0x00 << 0x08) | 0x06, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 16, 40, 8, 8);
// scs.Add((0x00 << 0x08) | 0x08, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 8, 40, 8, 8);
// scs.Add((0x00 << 0x08) | 0x60, "TLS_RSA_EXPORT_WITH_RC4_56_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// scs.Add((0x00 << 0x08) | 0x61, "TLS_RSA_EXPORT_WITH_RC2_CBC_56_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 7, 16, 56, 8, 8);
// 56 bits but we use 64 bits because of parity (DES is really 56 bits)
scs.Add((0x00 << 0x08) | 0x62, "TLS_RSA_EXPORT_WITH_DES_CBC_56_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 8, 8, 64, 8, 8);
scs.Add((0x00 << 0x08) | 0x64, "TLS_RSA_EXPORT_WITH_RC4_56_SHA", CipherAlgorithmType.Rc4, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// scs.Add((0x00 << 0x08) | 0x62, "TLS_RSA_EXPORT_WITH_DES_CBC_56_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 8, 8, 64, 8, 8);
// scs.Add((0x00 << 0x08) | 0x64, "TLS_RSA_EXPORT_WITH_RC4_56_SHA", CipherAlgorithmType.Rc4, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// Default CipherSuite
// scs.Add(0, "TLS_NULL_WITH_NULL_NULL", CipherAlgorithmType.None, HashAlgorithmType.None, ExchangeAlgorithmType.None, true, false, 0, 0, 0, 0, 0);
@@ -195,14 +195,14 @@ namespace Mono.Security.Protocol.Tls
scs.Add((0x00 << 0x08) | 0x09, "SSL_RSA_WITH_DES_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, false, true, 8, 8, 56, 8, 8);
// Supported exportable ciphers
scs.Add((0x00 << 0x08) | 0x03, "SSL_RSA_EXPORT_WITH_RC4_40_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 5, 16, 40, 0, 0);
scs.Add((0x00 << 0x08) | 0x06, "SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 16, 40, 8, 8);
scs.Add((0x00 << 0x08) | 0x08, "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 8, 40, 8, 8);
scs.Add((0x00 << 0x08) | 0x60, "SSL_RSA_EXPORT_WITH_RC4_56_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
scs.Add((0x00 << 0x08) | 0x61, "SSL_RSA_EXPORT_WITH_RC2_CBC_56_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 7, 16, 56, 8, 8);
// scs.Add((0x00 << 0x08) | 0x03, "SSL_RSA_EXPORT_WITH_RC4_40_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 5, 16, 40, 0, 0);
// scs.Add((0x00 << 0x08) | 0x06, "SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 16, 40, 8, 8);
// scs.Add((0x00 << 0x08) | 0x08, "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 5, 8, 40, 8, 8);
// scs.Add((0x00 << 0x08) | 0x60, "SSL_RSA_EXPORT_WITH_RC4_56_MD5", CipherAlgorithmType.Rc4, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// scs.Add((0x00 << 0x08) | 0x61, "SSL_RSA_EXPORT_WITH_RC2_CBC_56_MD5", CipherAlgorithmType.Rc2, HashAlgorithmType.Md5, ExchangeAlgorithmType.RsaKeyX, true, true, 7, 16, 56, 8, 8);
// 56 bits but we use 64 bits because of parity (DES is really 56 bits)
scs.Add((0x00 << 0x08) | 0x62, "SSL_RSA_EXPORT_WITH_DES_CBC_56_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 8, 8, 64, 8, 8);
scs.Add((0x00 << 0x08) | 0x64, "SSL_RSA_EXPORT_WITH_RC4_56_SHA", CipherAlgorithmType.Rc4, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// scs.Add((0x00 << 0x08) | 0x62, "SSL_RSA_EXPORT_WITH_DES_CBC_56_SHA", CipherAlgorithmType.Des, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, true, 8, 8, 64, 8, 8);
// scs.Add((0x00 << 0x08) | 0x64, "SSL_RSA_EXPORT_WITH_RC4_56_SHA", CipherAlgorithmType.Rc4, HashAlgorithmType.Sha1, ExchangeAlgorithmType.RsaKeyX, true, false, 7, 16, 56, 0, 0);
// Default CipherSuite
// scs.Add(0, "SSL_NULL_WITH_NULL_NULL", CipherAlgorithmType.None, HashAlgorithmType.None, true, false, 0, 0, 0, 0, 0);
@@ -129,6 +129,7 @@ namespace Mono.Security.Protocol.Tls
HandshakeType type, byte[] buffer)
{
ClientContext context = (ClientContext)this.context;
var last = context.LastHandshakeMsg;
switch (type)
{
@@ -148,23 +149,37 @@ namespace Mono.Security.Protocol.Tls
return null;
case HandshakeType.ServerHello:
if (last != HandshakeType.HelloRequest)
break;
return new TlsServerHello(this.context, buffer);
// Optional
case HandshakeType.Certificate:
if (last != HandshakeType.ServerHello)
break;
return new TlsServerCertificate(this.context, buffer);
case HandshakeType.ServerKeyExchange:
return new TlsServerKeyExchange(this.context, buffer);
// Optional
case HandshakeType.CertificateRequest:
return new TlsServerCertificateRequest(this.context, buffer);
if (last == HandshakeType.ServerKeyExchange || last == HandshakeType.Certificate)
return new TlsServerCertificateRequest(this.context, buffer);
break;
case HandshakeType.ServerHelloDone:
return new TlsServerHelloDone(this.context, buffer);
if (last == HandshakeType.CertificateRequest || last == HandshakeType.Certificate || last == HandshakeType.ServerHello)
return new TlsServerHelloDone(this.context, buffer);
break;
case HandshakeType.Finished:
return new TlsServerFinished(this.context, buffer);
// depends if a full (ServerHelloDone) or an abbreviated handshake (ServerHello) is being done
bool check = context.AbbreviatedHandshake ? (last == HandshakeType.ServerHello) : (last == HandshakeType.ServerHelloDone);
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone) {
context.ChangeCipherSpecDone = false;
return new TlsServerFinished (this.context, buffer);
}
break;
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
@@ -172,6 +187,7 @@ namespace Mono.Security.Protocol.Tls
"Unknown server handshake message received ({0})",
type.ToString()));
}
throw new TlsException (AlertDescription.HandshakeFailiure, String.Format ("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}
#endregion
@@ -122,6 +122,8 @@ namespace Mono.Security.Protocol.Tls
set { this.protocolNegotiated = value; }
}
public bool ChangeCipherSpecDone { get; set; }
public SecurityProtocolType SecurityProtocol
{
get
@@ -88,6 +88,8 @@ namespace Mono.Security.Protocol.Tls
} else {
ctx.StartSwitchingSecurityParameters (false);
}
ctx.ChangeCipherSpecDone = true;
}
public virtual HandshakeMessage GetMessage(HandshakeType type)
@@ -348,9 +350,6 @@ namespace Mono.Security.Protocol.Tls
// Try to read the Record Content Type
int type = internalResult.InitialBuffer[0];
// Set last handshake message received to None
this.context.LastHandshakeMsg = HandshakeType.ClientHello;
ContentType contentType = (ContentType)type;
byte[] buffer = this.ReadRecordBuffer(type, record);
if (buffer == null)
@@ -458,9 +457,6 @@ namespace Mono.Security.Protocol.Tls
// Try to read the Record Content Type
int type = recordTypeBuffer[0];
// Set last handshake message received to None
this.context.LastHandshakeMsg = HandshakeType.ClientHello;
ContentType contentType = (ContentType)type;
byte[] buffer = this.ReadRecordBuffer(type, record);
if (buffer == null)
@@ -523,87 +519,11 @@ namespace Mono.Security.Protocol.Tls
private byte[] ReadRecordBuffer (int contentType, Stream record)
{
switch (contentType)
{
case 0x80:
return this.ReadClientHelloV2(record);
default:
if (!Enum.IsDefined(typeof(ContentType), (ContentType)contentType))
{
throw new TlsException(AlertDescription.DecodeError);
}
return this.ReadStandardRecordBuffer(record);
}
}
private byte[] ReadClientHelloV2 (Stream record)
{
int msgLength = record.ReadByte ();
// process further only if the whole record is available
if (record.CanSeek && (msgLength + 1 > record.Length))
{
return null;
}
byte[] message = new byte[msgLength];
record.Read (message, 0, msgLength);
int msgType = message [0];
if (msgType != 1)
{
throw new TlsException(AlertDescription.DecodeError);
}
int protocol = (message [1] << 8 | message [2]);
int cipherSpecLength = (message [3] << 8 | message [4]);
int sessionIdLength = (message [5] << 8 | message [6]);
int challengeLength = (message [7] << 8 | message [8]);
int length = (challengeLength > 32) ? 32 : challengeLength;
// Read CipherSpecs
byte[] cipherSpecV2 = new byte[cipherSpecLength];
Buffer.BlockCopy (message, 9, cipherSpecV2, 0, cipherSpecLength);
// Read session ID
byte[] sessionId = new byte[sessionIdLength];
Buffer.BlockCopy (message, 9 + cipherSpecLength, sessionId, 0, sessionIdLength);
// Read challenge ID
byte[] challenge = new byte[challengeLength];
Buffer.BlockCopy (message, 9 + cipherSpecLength + sessionIdLength, challenge, 0, challengeLength);
if (challengeLength < 16 || cipherSpecLength == 0 || (cipherSpecLength % 3) != 0)
if (!Enum.IsDefined(typeof(ContentType), (ContentType)contentType))
{
throw new TlsException(AlertDescription.DecodeError);
}
// Updated the Session ID
if (sessionId.Length > 0)
{
this.context.SessionId = sessionId;
}
// Update the protocol version
this.Context.ChangeProtocol((short)protocol);
// Select the Cipher suite
this.ProcessCipherSpecV2Buffer(this.Context.SecurityProtocol, cipherSpecV2);
// Updated the Client Random
this.context.ClientRandom = new byte [32]; // Always 32
// 1. if challenge is bigger than 32 bytes only use the last 32 bytes
// 2. right justify (0) challenge in ClientRandom if less than 32
Buffer.BlockCopy (challenge, challenge.Length - length, this.context.ClientRandom, 32 - length, length);
// Set
this.context.LastHandshakeMsg = HandshakeType.ClientHello;
this.context.ProtocolNegotiated = true;
return message;
}
private byte[] ReadStandardRecordBuffer (Stream record)
{
byte[] header = new byte[4];
if (record.Read (header, 0, 4) != 4)
throw new TlsException ("buffer underrun");
@@ -1041,96 +961,5 @@ namespace Mono.Security.Protocol.Tls
}
#endregion
#region CipherSpecV2 processing
private void ProcessCipherSpecV2Buffer (SecurityProtocolType protocol, byte[] buffer)
{
TlsStream codes = new TlsStream(buffer);
string prefix = (protocol == SecurityProtocolType.Ssl3) ? "SSL_" : "TLS_";
while (codes.Position < codes.Length)
{
byte check = codes.ReadByte();
if (check == 0)
{
// SSL/TLS cipher spec
short code = codes.ReadInt16();
int index = this.Context.SupportedCiphers.IndexOf(code);
if (index != -1)
{
this.Context.Negotiating.Cipher = this.Context.SupportedCiphers[index];
break;
}
}
else
{
byte[] tmp = new byte[2];
codes.Read(tmp, 0, tmp.Length);
int tmpCode = ((check & 0xff) << 16) | ((tmp[0] & 0xff) << 8) | (tmp[1] & 0xff);
CipherSuite cipher = this.MapV2CipherCode(prefix, tmpCode);
if (cipher != null)
{
this.Context.Negotiating.Cipher = cipher;
break;
}
}
}
if (this.Context.Negotiating == null)
{
throw new TlsException(AlertDescription.InsuficientSecurity, "Insuficient Security");
}
}
private CipherSuite MapV2CipherCode(string prefix, int code)
{
try
{
switch (code)
{
case 65664:
// TLS_RC4_128_WITH_MD5
return this.Context.SupportedCiphers[prefix + "RSA_WITH_RC4_128_MD5"];
case 131200:
// TLS_RC4_128_EXPORT40_WITH_MD5
return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC4_40_MD5"];
case 196736:
// TLS_RC2_CBC_128_CBC_WITH_MD5
return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC2_CBC_40_MD5"];
case 262272:
// TLS_RC2_CBC_128_CBC_EXPORT40_WITH_MD5
return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC2_CBC_40_MD5"];
case 327808:
// TLS_IDEA_128_CBC_WITH_MD5
return null;
case 393280:
// TLS_DES_64_CBC_WITH_MD5
return null;
case 458944:
// TLS_DES_192_EDE3_CBC_WITH_MD5
return null;
default:
return null;
}
}
catch
{
return null;
}
}
#endregion
}
}
@@ -33,6 +33,8 @@ namespace Mono.Security.Protocol.Tls
{
internal class ServerRecordProtocol : RecordProtocol
{
TlsClientCertificate cert;
#region Constructors
public ServerRecordProtocol(
@@ -93,30 +95,45 @@ namespace Mono.Security.Protocol.Tls
private HandshakeMessage createClientHandshakeMessage(
HandshakeType type, byte[] buffer)
{
var last = context.LastHandshakeMsg;
switch (type)
{
case HandshakeType.ClientHello:
return new TlsClientHello(this.context, buffer);
case HandshakeType.Certificate:
return new TlsClientCertificate(this.context, buffer);
if (last != HandshakeType.ClientHello)
break;
cert = new TlsClientCertificate(this.context, buffer);
return cert;
case HandshakeType.ClientKeyExchange:
return new TlsClientKeyExchange(this.context, buffer);
if (last == HandshakeType.ClientHello || last == HandshakeType.Certificate)
return new TlsClientKeyExchange(this.context, buffer);
break;
case HandshakeType.CertificateVerify:
return new TlsClientCertificateVerify(this.context, buffer);
if (last == HandshakeType.ClientKeyExchange && cert != null)
return new TlsClientCertificateVerify(this.context, buffer);
break;
case HandshakeType.Finished:
return new TlsClientFinished(this.context, buffer);
// Certificates are optional, but if provided, they should send a CertificateVerify
bool check = (cert == null) ? (last == HandshakeType.ClientKeyExchange) : (last == HandshakeType.CertificateVerify);
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone) {
context.ChangeCipherSpecDone = false;
return new TlsClientFinished(this.context, buffer);
}
break;
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
throw new TlsException(AlertDescription.UnexpectedMessage, String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
break;
}
throw new TlsException (AlertDescription.HandshakeFailiure, String.Format ("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}
private HandshakeMessage createServerHandshakeMessage(
@@ -190,59 +190,15 @@ namespace Mono.Security.Protocol.Tls
this.Context.ClientWriteKey = keyBlock.ReadBytes(this.KeyMaterialSize);
this.Context.ServerWriteKey = keyBlock.ReadBytes(this.KeyMaterialSize);
if (!this.IsExportable)
if (this.IvSize != 0)
{
if (this.IvSize != 0)
{
this.Context.ClientWriteIV = keyBlock.ReadBytes(this.IvSize);
this.Context.ServerWriteIV = keyBlock.ReadBytes(this.IvSize);
}
else
{
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
this.Context.ClientWriteIV = keyBlock.ReadBytes(this.IvSize);
this.Context.ServerWriteIV = keyBlock.ReadBytes(this.IvSize);
}
else
{
HashAlgorithm md5 = MD5.Create();
int keySize = (md5.HashSize >> 3); //in bytes not bits
byte[] temp = new byte [keySize];
// Generate final write keys
md5.TransformBlock(this.Context.ClientWriteKey, 0, this.Context.ClientWriteKey.Length, temp, 0);
md5.TransformFinalBlock(this.Context.RandomCS, 0, this.Context.RandomCS.Length);
byte[] finalClientWriteKey = new byte[this.ExpandedKeyMaterialSize];
Buffer.BlockCopy(md5.Hash, 0, finalClientWriteKey, 0, this.ExpandedKeyMaterialSize);
md5.Initialize();
md5.TransformBlock(this.Context.ServerWriteKey, 0, this.Context.ServerWriteKey.Length, temp, 0);
md5.TransformFinalBlock(this.Context.RandomSC, 0, this.Context.RandomSC.Length);
byte[] finalServerWriteKey = new byte[this.ExpandedKeyMaterialSize];
Buffer.BlockCopy(md5.Hash, 0, finalServerWriteKey, 0, this.ExpandedKeyMaterialSize);
this.Context.ClientWriteKey = finalClientWriteKey;
this.Context.ServerWriteKey = finalServerWriteKey;
// Generate IV keys
if (this.IvSize > 0)
{
md5.Initialize();
temp = md5.ComputeHash(this.Context.RandomCS, 0, this.Context.RandomCS.Length);
this.Context.ClientWriteIV = new byte[this.IvSize];
Buffer.BlockCopy(temp, 0, this.Context.ClientWriteIV, 0, this.IvSize);
md5.Initialize();
temp = md5.ComputeHash(this.Context.RandomSC, 0, this.Context.RandomSC.Length);
this.Context.ServerWriteIV = new byte[this.IvSize];
Buffer.BlockCopy(temp, 0, this.Context.ServerWriteIV, 0, this.IvSize);
}
else
{
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
DebugHelper.WriteLine(">>>> KeyBlock", keyBlock.ToArray());
@@ -586,9 +586,21 @@ namespace Mono.Security.Protocol.Tls
break;
}
}
catch (TlsException ex)
{
try {
Exception e = ex;
this.protocol.SendAlert(ref e);
} catch {
}
negotiate.SetComplete(new IOException("The authentication or decryption has failed.", ex));
}
catch (Exception ex)
{
this.protocol.SendAlert(ref ex);
try {
this.protocol.SendAlert(AlertDescription.InternalError);
} catch {
}
negotiate.SetComplete(new IOException("The authentication or decryption has failed.", ex));
}
}
@@ -233,16 +233,8 @@ namespace Mono.Security.Protocol.Tls
// Send ServerCertificate message
this.protocol.SendRecord(HandshakeType.Certificate);
// If the negotiated cipher is a KeyEx cipher send ServerKeyExchange
if (this.context.Negotiating.Cipher.IsExportable)
{
this.protocol.SendRecord(HandshakeType.ServerKeyExchange);
}
// If the negotiated cipher is a KeyEx cipher or
// the client certificate is required send the CertificateRequest message
if (this.context.Negotiating.Cipher.IsExportable ||
((ServerContext)this.context).ClientCertificateRequired ||
// If the client certificate is required send the CertificateRequest message
if (((ServerContext)this.context).ClientCertificateRequired ||
((ServerContext)this.context).RequestClientCertificate)
{
this.protocol.SendRecord(HandshakeType.CertificateRequest);
@@ -123,45 +123,15 @@ namespace Mono.Security.Protocol.Tls
this.Context.ClientWriteKey = keyBlock.ReadBytes(this.KeyMaterialSize);
this.Context.ServerWriteKey = keyBlock.ReadBytes(this.KeyMaterialSize);
if (!this.IsExportable)
if (this.IvSize != 0)
{
if (this.IvSize != 0)
{
this.Context.ClientWriteIV = keyBlock.ReadBytes(this.IvSize);
this.Context.ServerWriteIV = keyBlock.ReadBytes(this.IvSize);
}
else
{
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
this.Context.ClientWriteIV = keyBlock.ReadBytes(this.IvSize);
this.Context.ServerWriteIV = keyBlock.ReadBytes(this.IvSize);
}
else
{
// Generate final write keys
byte[] finalClientWriteKey = PRF(this.Context.ClientWriteKey, "client write key", this.Context.RandomCS, this.ExpandedKeyMaterialSize);
byte[] finalServerWriteKey = PRF(this.Context.ServerWriteKey, "server write key", this.Context.RandomCS, this.ExpandedKeyMaterialSize);
this.Context.ClientWriteKey = finalClientWriteKey;
this.Context.ServerWriteKey = finalServerWriteKey;
if (this.IvSize > 0)
{
// Generate IV block
byte[] ivBlock = PRF(CipherSuite.EmptyArray, "IV block", this.Context.RandomCS, this.IvSize*2);
// Generate IV keys
this.Context.ClientWriteIV = new byte[this.IvSize];
Buffer.BlockCopy(ivBlock, 0, this.Context.ClientWriteIV, 0, this.Context.ClientWriteIV.Length);
this.Context.ServerWriteIV = new byte[this.IvSize];
Buffer.BlockCopy(ivBlock, this.IvSize, this.Context.ServerWriteIV, 0, this.Context.ServerWriteIV.Length);
}
else
{
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
this.Context.ClientWriteIV = CipherSuite.EmptyArray;
this.Context.ServerWriteIV = CipherSuite.EmptyArray;
}
DebugHelper.WriteLine(">>>> KeyBlock", keyBlock.ToArray());
@@ -68,6 +68,10 @@ namespace Mono.Security.X509 {
private byte[] certhash;
private RSA _rsa;
private DSA _dsa;
// from http://msdn.microsoft.com/en-gb/library/ff635835.aspx
private const string OID_DSA = "1.2.840.10040.4.1";
private const string OID_RSA = "1.2.840.113549.1.1.1";
// from http://www.ietf.org/rfc/rfc2459.txt
//
@@ -247,7 +251,7 @@ namespace Mono.Security.X509 {
if (m_keyalgoparams == null)
throw new CryptographicException ("Missing key algorithm parameters.");
if (_dsa == null) {
if (_dsa == null && m_keyalgo == OID_DSA) {
DSAParameters dsaParams = new DSAParameters ();
// for DSA m_publickey contains 1 ASN.1 integer - Y
ASN1 pubkey = new ASN1 (m_publickey);
@@ -327,7 +331,7 @@ namespace Mono.Security.X509 {
public virtual RSA RSA {
get {
if (_rsa == null) {
if (_rsa == null && m_keyalgo == OID_RSA) {
RSAParameters rsaParams = new RSAParameters ();
// for RSA m_publickey contains 2 ASN.1 integers
// the modulus and the public exponent
@@ -560,4 +564,4 @@ namespace Mono.Security.X509 {
return Convert.FromBase64String (base64);
}
}
}
}
@@ -39,9 +39,9 @@ using System.Runtime.InteropServices;
[assembly: AssemblyCompany (Consts.MonoCompany)]
[assembly: AssemblyProduct (Consts.MonoProduct)]
[assembly: AssemblyCopyright (Consts.MonoCopyright)]
[assembly: AssemblyVersion (Consts.FxVersion)]
[assembly: SatelliteContractVersion (Consts.FxVersion)]
[assembly: AssemblyInformationalVersion (Consts.FxFileVersion)]
[assembly: AssemblyVersion (XBuildConsts.AssemblyVersion)]
[assembly: SatelliteContractVersion (XBuildConsts.AssemblyVersion)]
[assembly: AssemblyInformationalVersion (XBuildConsts.FileVersion)]
[assembly: NeutralResourcesLanguage ("en-US")]
@@ -50,4 +50,4 @@ using System.Runtime.InteropServices;
[assembly: AssemblyDelaySign (true)]
[assembly: AssemblyKeyFile("../mono.pub")]
[assembly: AssemblyFileVersion (Consts.FxFileVersion)]
[assembly: AssemblyFileVersion (XBuildConsts.FileVersion)]
@@ -1,6 +1,7 @@
Assembly/AssemblyInfo.cs
../../build/common/Consts.cs
../../build/common/MonoTODOAttribute.cs
../../tools/xbuild/XBuildConsts.cs
Mono.XBuild.Tasks/PcFileCache.cs
Mono.XBuild.Tasks/LibraryPcFileCache.cs
../Microsoft.Build.Utilities/Mono.XBuild.Utilities/MSBuildUtils.cs
-905
View File
@@ -1,905 +0,0 @@
2009-11-20 Veerapuram Varadhan <[email protected]>
* Npgsql.dll.sources: Add
Npgsql{Factory,ConnectionStringBuilder}.cs
* Npgsql/NpgsqlConnectionString.cs: Comment out redefinition of
SslMode.
* Npgsql/NpgsqlConnectionStringBuilder.cs: Mark it for 2.x profile
onwards.
* Npgsql/NpgsqlFactory.cs: Make methods to work also on 2.x profile
2008-11-05 Francisco Figueiredo Jr. <[email protected]>
Undone update as it breaks the svn tree.
2008-11-05 Francisco Figueiredo Jr. <[email protected]>
Updated Npgsql to Npgsql2 2.0.1. Now Npgsql requires .Net 2.0 or above
2008-05-05 Francisco Figueiredo Jr. <[email protected]>
Fixed problems when notification thread throws exception. Not is
correctly thrown. See http://pgfoundry.org/forum/message.php?msg_id=1003387 for discussion about that. Thanks Josh Cooley for patch.
2007-11-15 Francisco Figueiredo Jr. <[email protected]>
*Npgsql/NpgsqlCommand.cs: [#1010187] Problem with parsing parameters and "<" or ">" operator with Prepare().
[#1010186] Thread safety problem when Parsing command text.
Thanks Hubert FONGARNAND for patches!
2007-11-09 Francisco Figueiredo Jr. <[email protected]>
*NpgsqlTypes/NpgsqlTypesHelper.cs: This is a single line patch version for handling Standard conforming strings parameter in postgresql.conf. You only need this version instead of 1.0 is you are using this setting or is planning to use it. Also, starting with 8.4 postgresql version, this parameter will be default to on in postgresql.conf. Today it is off.
More info can be obtained on this link: http://pgfoundry.org/tracker/index.php?func=detail&aid=1009624&group_id=1000140&atid=592
Thanks Laurenz Albe & Erich Lerch for their patch!
2006-11-01 Francisco Figueiredo Jr. <[email protected]>
*Npgsql/NpgsqlCommand.cs: [#1000765] InvalidCastException for ByteA
Parameter when command.Prepare() Thanks Hubert Fongarnand for patch!
2006-10-20 Francisco Figueiredo Jr. <[email protected]>
*Npgsql/NpgsqlCommand.resx,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlState.cs,
Npgsql/NpgsqlConnectorPool.cs,
Npgsql/NpgsqlCommandBuilder.cs,
Npgsql/NpgsqlDataReader.cs,
NpgsqlTypes/LargeObjectManager.cs,
NpgsqlTypes/NpgsqlDbType.cs,
NpgsqlTypes/LargeObject.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs,
NpgsqlTypes/FastPath.cs: Updated to 1.0 final version.
2006-09-06 Kornél Pál <[email protected]>
* Test/TestConfiguration.cs: Moved from build/common.
* Npgsql/Npgsql_test.dll.sources: Added TestConfiguration.cs.
2006-08-16 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlParameter.cs
Npgsql/NpgsqlConnectionString.cs
Npgsql/NpgsqlState.resx
Npgsql/NpgsqlConnection.cs
Npgsql/NpgsqlSchema.cs
Npgsql/NpgsqlClosedState.cs
Npgsql/NpgsqlCommand.cs
Npgsql/NpgsqlConnectorPool.cs
Npgsql/NpgsqlConnector.cs
Npgsql/NpgsqlTransaction.resx
Npgsql/NpgsqlRowDescription.cs
Npgsql/NpgsqlCommandBuilder.cs
Npgsql/NpgsqlDataReader.cs
Npgsql/NpgsqlException.cs
Npgsql/NpgsqlMediator.cs
Npgsql/NpgsqlReadyState.cs
NpgsqlTypes/NpgsqlDbType.cs
NpgsqlTypes/NpgsqlTypeConverters.cs
NpgsqlTypes/NpgsqlTypesHelper.cs: Updated to RC3 version.
2006-04-27 Francisco Figueiredo Jr. <[email protected]>
* Npgsql_test.dll.sources,
Npgsql.dll.sources,
Npgsql/NpgsqlError.cs,
Npgsql/NpgsqlCommandBuilder.resx,
Npgsql/NpgsqlConnectedState.cs,
Npgsql/NpgsqlBind.cs,
Npgsql/NpgsqlTransaction.cs,
Npgsql/NpgsqlConnectionString.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlClosedState.cs,
Npgsql/NpgsqlState.cs,
Npgsql/NpgsqlAsciiRow.cs,
Npgsql/NpgsqlConnector.cs,
Npgsql/NpgsqlParameterCollection.cs,
Npgsql/NpgsqlCancelRequest.cs,
Npgsql/NpgsqlCommandBuilder.cs,
Npgsql/NpgsqlException.cs,
Npgsql/NpgsqlMediator.cs,
Npgsql/NpgsqlReadyState.cs,
Npgsql/PGUtil.cs,
ChangeLog,
Npgsql.dll.resources,
NpgsqlTypes/NpgsqlDbType.cs,
NpgsqlTypes/NpgsqlTypeConverters.cs,
NpgsqlTypes/NpgsqlTypes.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs,
Makefile: Updated to RC1 version.
Thu Feb 23 10:29:13 CET 2006 Paolo Molaro <[email protected]>
* Npgsql/NpgsqlCommand.cs: return count for fetch and move, too,
patch from Federico Di Gregorio <[email protected]>.
2006-01-05 Francisco Figueiredo Jr. <[email protected]>
* PGUtil.cs: [#1000517] ServerVersion operator overload. Fixed. Thanks Otto for heads up.
2006-01-01 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlCommand.cs: [#1000497] Dot in parameter name causes exception. Added performance patch for GetClearCommandText() thanks Bryan Mayland.
* NpgsqlParameterCollection.cs: Added performance patch for GetClearCommandText() thanks Bryan Mayland.
* [#1000454] Getting identifier of an inserted row. Added property LastInsertedOID to NpgsqlCommand. This property only works when using a single insert command and the table was created with oids else it returns 0.
2005-12-29 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlCommand.cs: [#1000500] Fixed problem when parsing parameter names with NpgsqlCommand.Prepare(), [#1000497] Fixed problem with dot in parameter names.
2005-12-25 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTransaction.cs: [#1000491] Fixed transaction isolation level setting. Thanks Ottó Havasvölgyi for heads up.
* NpgsqlTransaction.cs.resx: Removed unused key.
2005-12-14 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlAsciiRow.cs,
NpgsqlBind.cs,
NpgsqlCommand.cs,
NpgsqlConnector.cs,
NpgsqlReadyState.cs,
NpgsqlState.cs,
NpgsqlTypesHelper.cs: [#1000458] Enormous memory increase (and application crash) with large BYTEA parameter. Added binary support. Thanks Hubert FONGARNAND for patch. Improved network performance by removing some Stream.Flush() calls.
2005-12-13 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlClosedState.cs: Added a performance improvement fix. Npgsql now use a buffered stream for all server interactions.
2005-12-12 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: [bugzilla 76961] Fixed problem with ExecuteReader when using SchemaOnly and SingleRow behavior at same time. Thanks Kamil Skalski for feedback.
2005-12-09 Francisco Figueiredo Jr. <[email protected]>
Npgsql/NpgsqlError.cs,
Npgsql/NpgsqlParameter.cs,
Npgsql/NpgsqlConnectionString.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlSchema.cs,
Npgsql/NpgsqlClosedState.cs,
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlState.cs,
Npgsql/NpgsqlAsciiRow.cs,
Npgsql/NpgsqlConnectorPool.cs,
Npgsql/NpgsqlConnector.cs,
Npgsql/NpgsqlQuery.cs,
Npgsql/NpgsqlRowDescription.cs,
Npgsql/NpgsqlCommandBuilder.cs,
Npgsql/NpgsqlDataReader.cs,
Npgsql/NpgsqlException.cs,
Npgsql/NpgsqlMediator.cs,
Npgsql/NpgsqlReadyState.cs,
Npgsql/NpgsqlEventLog.cs,
Npgsql.dll.resources,
NpgsqlTypes/NpgsqlTypeConverters.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs,
Makefile: Updated to 1.0beta1
2005-08-27 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlParameter.cs: Applied patch to fix a NullReferenceException when using Design Time support. Thanks Josh Cooley ( jbnpgsql at tuxinthebox dot net ) for patch.
* NpgsqlDataReader.cs: Updated ProviderType metadata from NpgsqlDataReader.GetResultsetSchema to be the string for the type rather than the oid. Fixed ColumnSize, NumericPrecision, NumericScale, BaseColumnName, AllowDBNull, and IsAliased. Also integrated patch from (rlp at bamafolks dot com), gborg 751. Thanks Josh Cooley (jbnpgsql at tuxinthebox dot net) for patches!
* NpgsqlConnection.cs,
NpgsqlSchema.cs: Josh Cooley (jbnpgsql at tuxinthebox dot net) improved Metadata support in Npgsql. Added support for the following collections through NpgsqlConnection.GetSchema() methods: MetaDataCollections, Restrictions, Databases, Tables, Columns, Views and Users. Also added support for restrictions when getting info about these collections.
* NpgsqlCommand.cs: Fixed problem with stored procedure command texts which finished with a ";". Npgsql was adding incorrectly a trailing "()" when calling this command text.
* NpgsqlDbType.cs,
NpgsqlTypesHelper.cs: Added refcursor parameter support. Now, refcursors can be passed as arguments for functions. Thanks Jon Asher for heads up and tests.
* Npgsql.dll.sources: Added helper metadata class. Thanks Josh Cooley (jbnpgsql at tuxinthebox dot net).
* NpgsqlDataAdapter: Updated constructor documentation.
* NpgsqlConnectorPool: Fixed concurrent problem when using MinPoolSize > 1. Thanks Josh Cooley (jbnpgsql at tuxinthebox dot net) for patch.
* NpgsqlParameterCollection.cs: Fixed problems with parameters with "@" prefix. They weren't correctly recognized. Thanks Pejvan Beigui ( pejvan at gmail dot com) for heads up.
* NpgsqlCommandBuilder.cs: Updated documentation.
2005-08-21 Francisco Figueiredo Jr. <[email protected]>
* Makefile,
Npgsql.dll.resources: Removed references to design time support. This is not needed when compiling Npgsql with mono.
2005-08-06 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlCommand.cs: Fixed problem when using commandtype.storedprocedure with command texts which have parameters with ' or any other value which needed to be escaped. Now they are properly handled. Thanks Dalibor (dalxxx at email dot com) for heads up and tests.
2005-08-05 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlConnection.cs: Fixed documentation about User Id connection string key. Thanks peyn at tlen dot pl for heads up. Fixes gborg 1388
2005-07-29 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlCommand.cs: Fixed problem with query strings with newlines. Regexp used to parse parameters were removing new line bytes creating query strings with errors. Thanks Jaroslaw Kowalski (jaak at jkowalski dot net) for fix.
2005-07-19 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypeConverters.cs: Gborg 1370. Fixed problems with Money type when using a culture which doesn't use dot as decimal separator. Also fixed problem where only Decimal types (i.e.: 7.4M) could be used as Money type values. Now Float values can be used too.
2005-07-08 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: Npgsql now can handle functions which return refcursor and setof refcursor. Now, results are returned as NpgsqlDataReader resultsets. There is no need to explicitly call "fetch all ..."
2005-07-05 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlDbType.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs,
Npgsql/NpgsqlParameter.cs,
Npgsql/NpgsqlConnectionString.cs,
Npgsql/NpgsqlState.resx,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlClosedState.cs,
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlConnector.cs,
Npgsql/NpgsqlParameterCollection.cs,
Npgsql/NpgsqlDataReader.cs,
Npgsql/NpgsqlException.cs: Updated to Npgsql 0.7beta6 gborg code.
2005-02-20 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: Fixed a problem when using prepare commands inside a transaction. Portal wasn't being released. We use the unnamed portal now. Thanks Marcin (marcin at floryan dot neostrada dot pl) for the heads up.
2005-02-13 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper.cs: gborg 1121: Fixed another culture variant representation problem when handling floating numbers. Thanks Sergey (sergey dot p dot k dot no dot spam at gmail dot com) for patch.
gborg 1167: Added support for writing null chars in text fields. Now they are escaped with \\0.
Thanks Sergey (sergey dot p dot k dot no dot spam at gmail dot com) for patch.
2005-02-08 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper.cs: Fixed float precision rounding. Now all float values are sent with 15 precision scale.
* Npgsql/NpgsqlCommand.cs: Fixed problem when setting a new connection and a running transaction existed. Now, the transaction can be removed and later the connection can be replaced. Thanks Mike Griffin (mike.griffin at mygenerationsoftware dot com) for heads up.
2005-02-06 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypeConverters.cs: Fixed datetime precision when sending values to backend. It was sending just the first 3 decimal values of time. Now it sends all the 6 digits. Thanks Martin Susil (spam at susil dot net) for heads up.
2005-01-29 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: Added support for updating output parameters when calling executereader().
Thanks Mike Griffin (mike dot griffin at mygenerationsoftware dot com) for heads up.
Fixed internal constructor to initialize Parameters collection and timeout.
2005-01-27 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlParameter.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlParameterCollection.cs,
Makefile: Fixed problem when compiling Npgsql with Mono on windows with cygwin. Thanks Atsushi Enomoto(atsushi at ximian dot com) for heads up and Rafael Teixeira(monoman at gmail dot com) for fix.
2005-01-24 Atsushi Enomoto <[email protected]>
* Makefile : quick csc build fix (tested on mcs as well).
2005-01-23 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypes.cs,
Npgsql.dll.sources,
Npgsql/NpgsqlParameter.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlParameterCollection.cs,
Makefile: Removed System.Drawing, System.Windows.Forms and System.Design dependency.
* NpgsqlTypes/NpgsqlTypesHelper.cs: Added patch for gborg 1121. Thanks regmaster (regmaster at gmx dot li) and torben (torben-spam-npsql at nehmer dot net) for patch.
2005-01-21 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlDbType.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs: Added support for Varchar datatype. Removed Internal data type enum. It is not supported yet.
* Npgsql/PGUtil.cs,
Npgsql/PGUtil.resx: (WriteString) Added support for logging what string is being written to database server.
* Npgsql/NpgsqlCommand.cs: Added SingleRow behavior support.
gborg 1099. Added support for record return type functions. Thanks neri and Michel for heads up and tests.
Fixed record function bug when function had many parameters. Thanks Neri (neri at gborg dot postgresql dot org) for heads up.
* Npgsql/NpgsqlCommandBuilder.cs,
NpgsqlDataAdapter.cs: Applied patch to fix gborg 1095. Thanks Eric van der Gutten (ericvdg at ananzi dot co dot za).
* Npgsql/NpgsqlDataReader.cs: Removed type conversions for GetXXX() methods.
2004-12-20 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: gborg 1099. Added support for record return type functions. Thanks neri and Michel for heads up and tests.
* Npgsql/NpgsqlDataReader.cs: Removed type conversions for GetXXX() methods.
* Npgsql/NpgsqlCommand.cs: Added IClonable implementation. Also added strong type NpgsqlTransaction property and converted previous interface implementation to implicit interface implementation. Thanks Christopher Gersbo-Møller (cgm at knowledgelab dot sdu dot dk) for heads up.
2004-12-19 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: Fixed gborg 1088 and 1080. Thanks Neri (neri at gborg dot postgresql dot org) for help. Now mapped output parameters are correctly updated regardless their position in Parameters collection.
2004-12-16 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnector.cs: Changed name of portal and prepare prefixes to be all lower case in order to not have case problems when deallocating them.
* Npgsql/NpgsqlCommand.cs: Fixed gborg 1082. Added support to implicit parameters when calling stored procedures.
2004-12-05 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnector (IsValid): Clean mediator after get a connection from pool and test it for validity. This fix a bug which some times occured which made available this test resultset to user when it shouldn't.
2004-12-07 Raja R Harinath <[email protected]>
* Makefile (CLEAN_FILES): Add $(RESX_RES).
($(the_lib)): Depend on $(OTHER_RES) too.
($(RESX_RES)): Pass argument of RESGEN through
PLATFORM_CHANGE_SEPARATOR_CMD.
2004-12-05 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: gborg 971 & 1068: Added support for ParameterDirection.Output and ParameterDirection.InputOutput parameters. Now you can use these types of parameters to get results. Thanks Ivan (ivan-sun1 at mail dot ru) and (teste at aslls dot ss) for heads up.
2004-11-26 Raja R Harinath <[email protected]>
* Makefile (OTHER_RES): New. List of .bmp files.
(EXTRA_DISTFILES): Distribute them.
2004-11-25 Francisco Figueiredo Jr. <[email protected]>
Updated to 0.7beta3 release.
* NpgsqlBind.cs: Minor code cleanup.
* NpgsqlClosedState.cs: Code formatting.
* NpgsqlCommand.cs: Code cleanup and updating for new Plan and Portal name generation code.
* NpgsqlConnection.cs: Fixed contructor log message.
* NpgsqlConnectionString.cs: Code formatting.
* NpgsqlConnector.cs:
ReleasePlansPortals: Added method to release used plans and portals.
NextPortalName, NextPlanName: Added methods to handle name generation.
* NpgsqlConnectorPool.cs:
UngetPooledConnector: Added call to release plans and portals in connector.
* NpgsqlError.cs: New constructor which takes ProtocolVersion and String parameters.
* NpgsqlQuery.cs: Changed constructor to take an NpgsqlCommand instead of just the command string.
* NpgsqlReadyState.cs: Changed code to reflect NpgsqlQuery change.
* NpgsqlState.cs:
ProcessBackendResponses_Ver_(2,3): Fixed handling of invalid authentication methods. Thanks Magnus Hagander (mha at sollentuna dot net) for the heads up.
* NpgsqlState.resx: Fixed resource key typo.
* NpgsqlTransaction.cs: Fixed IDisposable pattern implementation of NpgsqlTransaction. Now it doesn't incorrectly raise InvalidOperation exceptions. Thanks Ivan Radovanovic ( rivan at sezampro dot yu ) for heads up.
* NpgsqlDbType.cs: Code cleanup.
* NpgsqlTypeConverters.cs : Removed method to handle string. String quoting is handled prevously as it depends in the type of query: simple or extended.
* NpgsqlTypes.cs: Code cleanup.
* NpgsqlTypesHelper.cs:
(CreateAndLoadInitialTypesMapping): Removed delegate handler of String types. It's not necessary anymore.
(ConvertToBackend): Refactorying. Fixed gborg 1035. Thanks Magnus Hagander (mha at sollentuna dot net) for the heads up.
2004-11-25 Raja R Harinath <[email protected]>
* Makefile (EXTRA_DISTFILES): Add Npgsql.dll.resources.
2004-11-04 Raja R Harinath <[email protected]>
* Makefile (EXTRA_DISTFILES): Fix for 'make dist'.
2004-09-30 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/FastPath.cs,
NpgsqlTypes/FastPathArg.cs,
NpgsqlTypes/LargeObject.cs,
NpgsqlTypes/LargeObjectManager.cs,
Npgsql.dll.sources: Added large object support. Thanks Emiliano Necciari (e dot necciari at blogic dot it) for the patch.
2004-09-26 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataReader.cs:
GetBytes: Added a little fix for proper handling of getbytes with current Npgsql semantics in mind. For while, we just support offset value of 0 as we
read all the bytes field value at a time. So there is no copy when offset is not 0.
2004-09-25 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs:
GetParseCommandText: Fixed an incorrect patch. Thanks Martin ( martijn at boland dot org) for heads up.
2004-09-25 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs:
ReplaceParameterValue: Fixed parameter replace when next byte after parameter name is '\\r'. Thanks Ivan Radovanovic rivan at sezampro dot yu for the fix.
GetParseCommandText: Added a workaround to have some queries which are giving parameter type problems. Thanks Martin ( martijn at boland dot org) for bug report.
2004-09-23 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper.cs:
ConvertToBackend: Added support for System.Enum types. Now enumerated types can be used correctly as a paramater value. Thanks Martin ( martijn at boland dot org) for the heads up.
2004-09-18 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs:
GetClearCommandText: Fixed an infinite loop when trying to use a parameter whose name is equals to same type name.
i.e.: parameter name :text which would conflict with :text parameter name which was being added in the replacement string.
* NpgsqlTypes/NpgsqlTypeConverters.cs:
BasicNativeToBackendTypeConverter.ToString: Fixed handling of strings with backslashes. Now they are properly escaped.
2004-09-18 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlCommand.cs,
NpgsqlConnector.cs: Improved portal and plan name creation to use an unique number from NpgsqlConnector instead of using an static field in NpgsqlCommand. Thanks Martin ( martijn at boland dot org) for the heads up.
2004-09-15 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlRowDescription.cs:
FieldIndex: Really added support for case insensitive fields index lookup. Thanks Martin ( martijn at boland dot org)
2004-09-14 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlRowDescription.cs:
FieldIndex: Added support for case insensitive fields index lookup. Thanks Martin ( martijn at boland dot org)
2004-09-12 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper:
VerifyDefaultTypesMap: Added DbType.Byte support. Thanks Martin ( martijn at boland dot org)
for heads up.
2004-09-12 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper:
ConvertToBackend: Fixed code to handle null values properly when using extended query mode.
Fix bug 955 in gborg.
2004-09-11 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs:
Dispose: Improved implementation. Also added warning logging for
NpgsqlConnection leakings.
Close: Fixed code to allow calling many times even when being disposed.
* Npgsql/NpgsqlConnection.resx:
Added new warning logging message for NpgsqlConnection leakings.
* Npgsql/NpgsqlConnector.cs:
IsValid: new method to check if Connector is still valid.
* Npgsql/NpgsqlConnectorPool.cs:
GetPooledConnector: Improved to check validity of Connector.
FixPoolCountBecauseOfConnectionDisposeFalse: new method to fix the connection pool count
because NpgsqlConnection leaking. This way, uses doesn't run out of connections from pool.
2004-09-07 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlException.cs: Added support for deserialization of NpgsqlException.
* NpgsqlState.cs: Added missing handling of NoData message.
2004-07-02 Raja R Harinath <[email protected]>
* Makefile (OVERRIDE_BARE_TARGETS): Remove.
($(the_lib)): Make dependency explicit.
2004-06-28 Raja R Harinath <[email protected]>
* Makefile (%.resources): Use $(RESGEN).
2004-06-22 Raja R Harinath <[email protected]>
* Makefile: Use $(PLATFORM_PATH_SEPARATOR) in MONO_PATH.
2004-06-21 Raja R Harinath <[email protected]>
* Makefile (LIBRARY_SNK): Sign with Npgsql/Npgsql.snk.
2004-06-18 Francisco Figueiredo Jr. <[email protected]>
* Synchronized files with gborg cvs up to release 0.6.
2004-05-29 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs: Added workaround for redhat server versions.
It returns 7.3.4-RH as its server version. Thanks Jaroslaw Kowalski
([email protected]) for the patch.
2004-05-24 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs: Fixed bug when handling Unicode connections.
Fixes Gborg bug 752.
Thanks [email protected] for the patch.
2004-05-23 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs: Fixed bug which prevented Npgsql to
connect to cvs built servers which had devel in its version string.
2004-05-22 Francisco Figueiredo Jr. <[email protected]>
Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlDataReader.cs,
Npgsql/NpgsqlException.cs,
Npgsql/NpgsqlTransaction.cs,
Npgsql/Design/ConnectionStringEditor.cs,
Npgsql/Design/ConnectionStringEditorForm.cs,
Npgsql/Design/NpgsqlParameterConverter.cs,
Npgsql/Design/NpgsqlParametersEditor.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs: Commit log by
Glen Parker ([email protected]): Bug #772 ("Using
Command and Prepare adds single quotes to strings twice")
is fixed :-) It was broken when running on the version 3
protocol (extended query support) on PostgreSQL 7.4.
Some of the files in Design were formatted with macintosh line
terminators. This was screwing up the xmldoc generator in csc,
so I reformatted to make it work.
I've added some essential xmldoc comments (<summary> tags). Much work
remains here, but I wanted to get a few in on common functions and
properties.
The .build file will now generate the Npgsql.xml file, next to the .dll
file. I removed the existing Npgsql.xml from CVS.
Thanks Glen Parker for this patch.
2004-05-20 Francisco Figueiredo Jr. <[email protected]>
NpgsqlAsciiRow.cs,
NpgsqlBackEndKeyData.cs,
NpgsqlBinaryRow.cs,
NpgsqlCommand.cs,
NpgsqlConnectedState.cs,
NpgsqlConnection.cs,
NpgsqlConnection.resx,
NpgsqlConnector.cs,
NpgsqlConnectorPool.cs,
NpgsqlError.cs,
NpgsqlMediator.cs,
NpgsqlMessageTypes.cs,
NpgsqlPasswordPacket.cs,
NpgsqlQuery.cs,
NpgsqlRowDescription.cs,
NpgsqlStartupPacket.cs,
NpgsqlState.cs,
PGUtil.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs : - store protocol version as an enum, keep numbers as protocol specific
- split more protocol handlers between version 2 and version 3
- split MessageTypes class on ver2/ver3 and add remaining types for ver3 - removed handlers for deprecated protocol message types
- store BackendKeyData in its own member on Mediator
- Store ParameterStatus objects in a key map on Mediator
- Get backend version now from the Mediator if possible
- Rewrite parsers for server version and connection string
- Store server version numericially (in a new class ServerVersion)
- As usual, lots of code cleanup/commenting/etc.
Thanks very much Glen Parker ([email protected]) for this patch.
2004-05-20 Raja R Harinath <[email protected]>
* Makefile (%.resources): Use INTERNAL_RESGEN.
2004-05-13 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlHashAlgorithm.cs: Changed exception type from Exception t
o InvalidOperationException when calling the Hash property and hash value is nul
l. Thanks Gonzalo Paniagua Javier <[email protected]> for catching that.
2004-05-09 Francisco Figueiredo Jr. <[email protected]>
* HashAlgorithm.cs,
NpgsqlAsciiRow.cs,
NpgsqlBinaryRow.cs,
NpgsqlClosedState.cs,
NpgsqlCommand.cs,
NpgsqlCommandBuilder.cs,
NpgsqlConnection.cs,
NpgsqlDataReader.cs,
NpgsqlException.cs,
NpgsqlParameterCollection.cs,
NpgsqlReadyState.cs,
NpgsqlTransaction.cs: Improved exception handling. Now Npgsql throws mor
e meaningful exceptions instead of throw NpgsqlException which are now exclusive
ly to sign server errors. Thanks Glen Parker ([email protected]) for the patch.
2004-05-05 Gonzalo Paniagua Javier <[email protected]>
* Makefile:
* Npgsql.dll.resources: all the resources command line options are now
in a separate response file.
2004-05-04 Jaroslaw Kowalski <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Fixed RecordsAffected to properly return -1 after "create table" and similar commands.
2004-05-01 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs,
Npgsql/NpgsqlConnection.cs,
Npgsql/NpgsqlConnector.cs,
Npgsql/NpgsqlConnectorPool.cs,
Npgsql/NpgsqlError.cs,
Npgsql/NpgsqlException.cs,
Npgsql/NpgsqlParameterCollection.cs,
NpgsqlTypes/NpgsqlTypesHelper.cs: Improved exception support. Now NpgsqlException as well as NpgsqlError provide much more information. Thanks Glen Parker ([email protected]) for the patch.
2004-04-30 Todd Berman <[email protected]>
* Npgsql/AssemblyInfo.cs: use the proper path to the .pub file
2004-04-30 Duncan Mak <[email protected]>
* Npgsql/AssemblyInfo.cs: Enable delay signing, using Npgsql.pub.
* Npgsql/Npgsql.pub: Added to CVS.
2004-04-21 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Changed RowUpdated and RowUpdating prefix to Npgsql.
* Npgsql/NpgsqlClosedState.cs: Removed dependency in TlsException. Carlos Guzman will change this excpetion to internal.
* Npgsql/NpgsqlCommand.cs
* Npgsql/NpgsqlCommand.resx
* Npgsql/NpgsqlConnection.cs
* Npgsql/NpgsqlConnection.resx
* Npgsql/NpgsqlDataAdapter.cs
* Npgsql/NpgsqlError.cs
* Npgsql/NpgsqlException.cs
* Npgsql/NpgsqlException.resx
* Npgsql/NpgsqlMediator.cs
* Npgsql/NpgsqlState.cs
* Npgsql/NpgsqlState.resx
* Npgsql/PGUtil.cs : Added initial error handling code improvements. Thanks Glen Parker ([email protected]) for the patch. NpgsqlException now gives aceess to error collection through the Errors property. This property return a collection of NpgsqlErrors objects. Also it gives access to error message, hint, severity and code. This fixes the feature request 689 in gborg.
2004-04-09 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Fixed DataAdapter to raise the RowUpdating and RowUpdated events. This also fixes some issues in gborg 710 bug. This modification may have broken CommandBuilder support. Working on that.
2004-03-28 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlTransaction.cs: Fixed a bug where rollback was being called when disposing NpgsqlTransaction objects even when transaction was sucessfully commited. Fixes bug 725 in gborg. Thanks melkor ([email protected]) for spotting that.
2004-03-28 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs: Implemented IClonable interface in NpgsqlConnection class. Thanks Juliano Barbosa for pointing it out.
2004-03-22 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlAsciiRow.cs
* Npgsql/NpgsqlBinaryRow.cs
* Npgsql/NpgsqlDataReader.cs: Fixed NpgsqlDataReader.IsDBNull(). It wasn't working for postgresql 7.4+. Thanks Glen Parker ([email protected]) for the patch.
2004-03-13 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs:
* Npgsql/NpgsqlClosedState.cs: Added support for SSL callbacks points. Now, client applications can provide the callbacks. Npgsql provide a default callback implementation which always assumes the certificate is ok. This allows easy use as client don't need to provide callback to use ssl connections. This also fixes bug 705 in gborg.
* NpgsqlTypes/NpgsqlTypesHelper: Applied patch to correctly parse datetimes values with timezone information. Thanks Glen Parker <[email protected]> for the patch.
2004-03-06 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnectorPool.cs: Fixed bug 706 in gborg. Now Max timeout will be working correctly. Thanks Sami Kuhmonen <[email protected]> for the patch.
2004-02-29 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnection.cs: Better handling of connection encoding. Added support for encoding and connection timeout in connection string.
* Npgsql/NpgsqlConnectorPool.cs: Added support for timeout and max connection pool.
2004-02-28 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlConnector.cs: Added support for connection encoding.
* Npgsql/NpgsqlConnection.cs: Better handling of connection encoding.
* Npgsql/NpgsqlCommand.cs: Fixed an Invalid Index error when executing ExecuteScalar() method with an empty resultset. Thanks Lynn A. Roth for the fix. This fixes bug 687 in gborg.
2004-02-25 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Fixed a OutOfBoundsException when trying to access an element after have read all elements. Now it throws an InvalidOperationException.
* Npgsql/NpgsqlConnection.cs: Fixed Unicode handling. This also fixes bug 695 in gborg. Thanks Sami Kuhmonen <[email protected]> for the patch.
2004-02-16 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Removed a log line which reduced the conne
ction startup time in 300 milliseconds.
2004-02-16 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlConnection.cs: Added support for Unicode encoding. Fixes feature
request 534 on gborg. Thanks Ivar <[email protected]> for pointing it out.
2004-02-16 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlStartupPacket.cs: Added code to set datestyle to iso when
connecting using protocol 3.0 version. Thanks Sami Kuhmonen <[email protected]> for pointing it out.
2004-02-14 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlCommand.cs: Fixed a bug when handling queries which return no data. Thanks Morten Mertner <[email protected]> for the fix.
2004-02-10 Francisco Figueiredo Jr. <[email protected]>
* NpgsqlTypes/NpgsqlTypesHelper.cs: Added support for datetime and time datatypes with timezone data. Thanks Sami Kuhmonen ([email protected]).
2004-01-15 Jackson Harper <[email protected]>
* NpgslTypes/NpgsqlTypesHelper.cs: Add StringFixedLength type.
2003-11-23 Pedro Martínez Juliá <[email protected]>
* Npgsql/HashAlgorithm.cs:
* Npgsql/NpgsqlClosedState.cs:
* Npgsql/NpgsqlCommand.cs:
* Npgsql/NpgsqlConnectedState.cs:
* Npgsql/NpgsqlConnection.cs:
* Npgsql/NpgsqlReadyState.cs:
* Npgsql/NpgsqlStartupState.cs:
* Npgsql/NpgsqlState.cs: Apply Disposable pattern, when using
ADO.NET we need to call Dispose after using any Component like
NpgsqlDataAdapter, NpgsqlConnection, etc... Change a few internal
methods to Properties.
2003-11-22 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlClosedState.cs:
* Npgsql/NpgsqlConnectedState.cs:
* Npgsql/NpgsqlConnection.cs:
* Npgsql/NpgsqlReadyState.cs:
* Npgsql/NpgsqlState.cs: Changes related to the last update of SSL
implementation. Now we're using TcpClient for the connection and
Stream for the abstraction layer to SslClientStream.
2003-11-11 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataReader.cs: GetSchemaTable has nothing to do with
CanRead because the schema can be readed with or without result
rows.
2003-11-10 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Best use "if" instead of try-catch.
2003-11-10 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Catch the exception thrown by MS.NET
when a mapping is not in the collection.
2003-11-09 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Do not assing the result of the
CommandBuilder to the local data. Local data should be null if the
client doesn't set them.
* Npgsql/NpgsqlCommandBuilder.cs: Mistake in param name fixed.
2003-11-09 Pedro Martínez Juliá <[email protected]>
* Makefile: Little fix for build the resources.
* Npgsql/NpgsqlCommandBuilder.cs: Added row version in delete
command.
2003-11-08 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlCommand.cs: Removed try-catch for Resource Manager
calls, the problem is fixed.
* Makefile: Fix one bug in the build of resources.
2003-11-08 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlCommandBuilder.cs: Added the command builder.
* Npgsql/NpgsqlDataAdapter.cs: Added the CommandBuilder stuff. When
OnRowUpdating is called we create the command necesary for updating,
inserting or deleting any row of the DataTable/DataSet.
* Npgsql/NpgsqlCommand.cs: Temporary try-catch. ResMan still doesn't
work. This must be removed when ResMan works.
* Npgsql/NpgsqlParameter: No more than one call to value.GetType()
is more efficient for the deep if structure types.
2003-11-07 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Fixed the mistake I did in the last
change. The Command objects must not be created in the constructor.
The Commands should be in the overrided method "OnRowUpdating".
* Npgsql/NpgsqlCommand.cs: Added two try-catch instructions to get
the proper exception (not MissingManifestResourceException). It is
thrown in MS.NET and in MONO. (Npgsql compiled with MCS).
2003-11-07 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataAdapter.cs: Create new Command classes for the
different Insrt / Update / Delete commands.
2003-10-20 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlClosedState.cs:
* Npgsql/NpgsqlConnection.cs:
* Npgsql/NpgsqlConnectedState.cs:
* Npgsql/NpgsqlReadyState.cs:
* Npgsql/NpgsqlState.cs: Changed the namespace for Tls, now the
namespace is Mono.System.Protocol.Tls, before was
System.Security.Tls.
* Npgsql/Makefile: Change reference from System.Security.Tls to
Mono.Security (now Tls lives there).
2003-10-16 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlClosedState.cs:
* Npgsql/NpgsqlConnectedState.cs:
* Npgsql/NpgsqlConnection.cs: Changed TcpClient by TlsSession
because now it is used TlsSession and it doesn't work without
these changes.
2003-10-16 Pedro Martínez Juliá <[email protected]>
* Makefile: changed reference from Lib/System.Security.Tls.dll to
System.Security.Tls because the last will be installed before and
separatelly.
* Lib: Removed Lib directory, moved System.Security.Tls.dll to
Mono.Security.Tls library directory.
2003-10-15 Pedro Martínez Juliá <[email protected]>
* Makefile: fix building and the install objectives.
2003-04-26 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Change GetFloat and GetDouble. Now
they works as direct casting from GetValue.
2003-07-18 Peter Williams <[email protected]>
* Npgsql/AssemblyInfo.cs: Don't strongname the assembly, because
we can't unless corlib is strongnamed too. Not a wonderful solution,
but I don't think this ever worked anyway.
2003-05-25 Francisco Figueiredo Jr. <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Fixed an invalid index exception when
processing 0 rows queries.
2003-04-26 Pedro Martínez Juliá <[email protected]>
* Npgsql/NpgsqlDataReader.cs: Now GetDateTime works for "dd/MM/yyyy"
date formats. I think that it's needed support to auto-detect
DateTime format through PgSql server configuration.
2003-01-28 Daniel Morgan <[email protected]>
* Npgsql.build: got it to work for Windows build
* Npgsql/Npgsql.build
* Npgsql/Npgsql.cmbx
* Npgsql/Npgsql.prjx: removed files not needed
2003-01-28 Daniel Morgan <[email protected]>
* added the Npgsql (Npgsql is a .Net Data Provider for PostgreSQL)
from http://gborg.postgresql.org/project/npgsql/projdisplay.php
by adding the following files and directories to the mcs module
in mono-cvs.ximian.com at mcs/class:
Npgsql (directory)
ChangeLog
Makefile
Npgsql.build
RELEASENOTES.txt
TODO.txt
makefile.gnu
LICENSE.txt
README.txt
STATUS.txt
list
Npgsql/Npgsql (directory)
Npgsql/AssemblyInfo.cs
Npgsql/NpgsqlAsciiRow.cs
Npgsql/NpgsqlBackEndKeyData.cs
Npgsql/NpgsqlClosedState.cs
Npgsql/NpgsqlCommand.cs
Npgsql/NpgsqlConnectedState.cs
Npgsql/NpgsqlConnection.cs
Npgsql/NpgsqlConnector.cs
Npgsql/NpgsqlConnectorPool.cs
Npgsql/NpgsqlDataAdapter.cs
Npgsql/NpgsqlDataReader.cs
Npgsql/NpgsqlEventLog.cs
Npgsql/NpgsqlException.cs
Npgsql/NpgsqlMediator.cs
Npgsql/NpgsqlMessageTypes.cs
Npgsql/NpgsqlParameter.cs
Npgsql/NpgsqlParameterCollection.cs
Npgsql/NpgsqlPasswordPacket.cs
Npgsql/NpgsqlQuery.cs
Npgsql/NpgsqlReadyState.cs
Npgsql/NpgsqlResultSet.cs
Npgsql/NpgsqlRowDescription.cs
Npgsql/NpgsqlStartupPacket.cs
Npgsql/NpgsqlStartupState.cs
Npgsql/NpgsqlState.cs
Npgsql/NpgsqlTransaction.cs
Npgsql/PGUtil.cs
@@ -1,72 +0,0 @@
<Type Name="LogLevel" FullName="Npgsql.LogLevel">
<TypeSignature Language="C#" Value="public enum LogLevel" Maintainer="auto" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Enum</BaseTypeName>
</Base>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Debug">
<MemberSignature Language="C#" Value="Debug" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.LogLevel</ReturnType>
</ReturnValue>
<Parameters>
</Parameters>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="None">
<MemberSignature Language="C#" Value="None" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.LogLevel</ReturnType>
</ReturnValue>
<Parameters>
</Parameters>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Normal">
<MemberSignature Language="C#" Value="Normal" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.LogLevel</ReturnType>
</ReturnValue>
<Parameters>
</Parameters>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,24 +0,0 @@
<Type Name="NoticeEventHandler" FullName="Npgsql.NoticeEventHandler">
<TypeSignature Language="C#" Value="public delegate void NoticeEventHandler(object sender, NpgsqlNoticeEventArgs e);" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Parameters>
<Parameter Name="sender" Type="System.Object" />
<Parameter Name="e" Type="Npgsql.NpgsqlNoticeEventArgs" />
</Parameters>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Docs>
<param name="sender">To be added.</param>
<param name="e">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Type>
@@ -1,29 +0,0 @@
<Type Name="NotificationEventHandler" FullName="Npgsql.NotificationEventHandler">
<TypeSignature Language="C#" Maintainer="auto" Value="public delegate void NotificationEventHandler(object sender, NpgsqlNotificationEventArgs e);" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.5.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Docs>
<param name="sender">To be added.</param>
<param name="e">To be added.</param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members />
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="sender" Type="System.Object" />
<Parameter Name="e" Type="Npgsql.NpgsqlNotificationEventArgs" />
</Parameters>
</Type>
@@ -1,656 +0,0 @@
<Type Name="NpgsqlCommand" FullName="Npgsql.NpgsqlCommand">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlCommand : System.ComponentModel.Component, ICloneable, System.Data.IDbCommand" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.ComponentModel.Component</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Data.IDbCommand</InterfaceName>
</Interface>
<Interface>
<InterfaceName>System.ICloneable</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>Represents a command to be executed against the PostgreSQL database backend.</summary>
<remarks>
<para>
An NpgsqlCommand object is associated with a <see cref="T:Npgsql.NpgsqlConnection" /> instance.It can be used to execute
SQL statements (SELECT, INSERT, UPDATE, DELETE, etc.), stored procedures and functions against the database the <see cref="T:Npgsql.NpgsqlConnection" />
instance referenced in the <see cref="P:Npgsql.NpgsqlCommand.Connection" /> is associated with.
</para>
<para>
As the NpgsqlCommand implements the <see cref="T:System.Data.IDbCommand" /> interface, it can be used to
<list type="bullet"><item><term>Execute queries without expecting a result back using the
<see cref="M:Npgsql.NpgsqlCommand.ExecuteNonQuery" /> method</term></item><item><term>Execute queries only a single (scalar) result back using the
<see cref="M:Npgsql.NpgsqlCommand.ExecuteScalar" /> method</term></item><item><term>Execute queries without expecting a
<see cref="Npgsql.NpgsqlDataReader" /> back using the <see cref="M:Npgsql.NpgsqlCommand.ExecuteDataReader" /></term></item></list></para>
</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommand ();" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommand (string cmdText);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="cmdText" Type="System.String" />
</Parameters>
<Docs>
<param name="cmdText">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommand (string cmdText, Npgsql.NpgsqlConnection connection);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="cmdText" Type="System.String" />
<Parameter Name="connection" Type="Npgsql.NpgsqlConnection" />
</Parameters>
<Docs>
<param name="cmdText">a <see cref="T:System.String" /></param>
<param name="connection">a <see cref="T:Npgsql.NpgsqlConnection" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommand (string cmdText, Npgsql.NpgsqlConnection connection, Npgsql.NpgsqlTransaction transaction);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="cmdText" Type="System.String" />
<Parameter Name="connection" Type="Npgsql.NpgsqlConnection" />
<Parameter Name="transaction" Type="Npgsql.NpgsqlTransaction" />
</Parameters>
<Docs>
<param name="cmdText">a <see cref="T:System.String" /></param>
<param name="connection">a <see cref="T:Npgsql.NpgsqlConnection" /></param>
<param name="transaction">a <see cref="T:Npgsql.NpgsqlTransaction" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Cancel">
<MemberSignature Language="C#" Value="public void Cancel ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Clone">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand Clone ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="CommandText">
<MemberSignature Language="C#" Value="public string CommandText { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="CommandTimeout">
<MemberSignature Language="C#" Value="public int CommandTimeout { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(20)</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="CommandType">
<MemberSignature Language="C#" Value="public System.Data.CommandType CommandType { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.CommandType</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.CommandType" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(System.Data.CommandType.Text)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="Connection">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlConnection Connection { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlConnection</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>Connection to the PostgreSQL backend</summary>
<value>a <see cref="T:Npgsql.NpgsqlConnection" /> object</value>
<remarks>
The Connection property is a reference to the <see cref="T:Npgsql.NpgsqlConnection" /> the commands will be executed against.
The connection must be open before the command can be executed. If a command is executed against a closed connection,
a <see cref="T:System.InvalidOperationException" /> is thrown.
</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(null)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Behavior")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="CreateParameter">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter CreateParameter ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlParameter" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ExecuteNonQuery">
<MemberSignature Language="C#" Value="public int ExecuteNonQuery ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>Executes a query against the database backend without expecting data back from it</summary>
<returns>A <see cref="T:System.Int32" /> containing the number of records affected on the database by the query</returns>
<remarks>
<para>
The <see cref="M:Npgsql.NpgsqlCommand.ExecuteNonQuery" /> method is used to execute a query against the database
without exepecting a result back. This is useful for running data manipulation commands, etc.
</para>
<para>
The following example demonstrates the use of the method against a database. For the example to work, a user 'joe'
with the password 'secret' needs to have access to the 'table1' table in the 'joedata' database created with the SQL
</para>
<c>
CREATE TABLE table1 (int1 INTEGER, int2 INTEGER);
</c>
<code lang="C#">
/* Compiling:
* mcs -r:Npgsql -r:System.Data NpgsqlExecuteNonQuery.cs
*/
using System;
using System.Data;
using Npgsql;
public class NpgsqlExecuteNonQuery
{
public static void Main(String[] args)
{
NpgsqlConnection conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
conn.Open();
NpgsqlCommand command = new NpgsqlCommand("insert into table1 values(1, 1)", conn);
Int32 rowsaffected;
try
{
rowsaffected = command.ExecuteNonQuery();
Console.WriteLine("Just added {0} lines in the table table1", rowsaffected);
}
finally
{
conn.Close();
}
}
}
</code>
<para>
Executing the query should give the output
</para>
<c>Just added 1 lines in the table table1</c>
</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ExecuteReader">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlDataReader ExecuteReader ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlDataReader</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>Executes a query against the database backend, creating a <see cref="T:Npgsql.NpgsqlDataReader" />
which can be used for forward-only reading of data from the database.</summary>
<returns>a <see cref="T:Npgsql.NpgsqlDataReader" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ExecuteReader">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlDataReader ExecuteReader (System.Data.CommandBehavior cb);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlDataReader</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="cb" Type="System.Data.CommandBehavior" />
</Parameters>
<Docs>
<param name="cb">a <see cref="T:System.Data.CommandBehavior" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlDataReader" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ExecuteScalar">
<MemberSignature Language="C#" Value="public object ExecuteScalar ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>Executes a query against the <see cref="T:Npgsql.NpgsqlConnection" /> and expects a single value as output</summary>
<returns>a <see cref="T:System.Object" /> containing the output value.</returns>
<remarks>
<para>
This command returns a single value as the output of the command execution.
</para>
<code lang="C#">
using System;
using System.Data;
using Npgsql;
public class NpgsqlExecuteScalar
{
public static void Main(String[] args)
{
NpgsqlConnection conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
conn.Open();
NpgsqlCommand command = new NpgsqlCommand("select version()", conn);
String serverversion;
try
{
serverversion = (String)command.ExecuteScalar();
Console.WriteLine("PostgreSQL server version: {0}", serverversion);
}
finally
{
conn.Close();
}
}
}
</code>
<para>
Compiling and executing the above code gives the output
</para>
<c>PostgreSQL server version: PostgreSQL 7.3.2 on i386-redhat-linux-gnu, compiled by GCC i386-redhat-linux-gcc (GCC) 3.2.2 20030213 (Red Hat Linux 8.0 3.2.2-1)</c>
<para>
If a query is executed that returns more than one column and/or more than one row, only the first column in the first row is returned.
For example, tweaking the above example to make it
<code Lang="C#">
using System;
using System.Data;
using Npgsql;
public class NpgsqlExecuteScalar
{
public static void Main(String[] args)
{
NpgsqlConnection conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
conn.Open();
NpgsqlCommand command = new NpgsqlCommand("select version(), upper('foo')", conn);
String serverversion;
try
{
serverversion = (String)command.ExecuteScalar();
Console.WriteLine("PostgreSQL server version: {0}", serverversion);
}
finally
{
conn.Close();
}
}
}
</code>
still prints
</para>
<c>PostgreSQL server version: PostgreSQL 7.3.2 on i386-redhat-linux-gnu, compiled by GCC i386-redhat-linux-gcc (GCC) 3.2.2 20030213 (Red Hat Linux 8.0 3.2.2-1)</c>
<para>
Note that the exact output in the above will vary depending on the exact version of the database.
</para>
</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="LastInsertedOID">
<MemberSignature Language="C#" Value="public long LastInsertedOID { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Int64</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Parameters">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameterCollection Parameters { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameterCollection</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlParameterCollection" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Prepare">
<MemberSignature Language="C#" Value="public void Prepare ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="System.Data.IDbCommand.Connection">
<MemberSignature Language="C#" Value="System.Data.IDbConnection System.Data.IDbCommand.Connection { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbConnection</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbCommand.CreateParameter">
<MemberSignature Language="C#" Value="System.Data.IDbDataParameter IDbCommand.CreateParameter ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbDataParameter</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbCommand.ExecuteReader">
<MemberSignature Language="C#" Value="System.Data.IDataReader IDbCommand.ExecuteReader ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDataReader</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbCommand.ExecuteReader">
<MemberSignature Language="C#" Value="System.Data.IDataReader IDbCommand.ExecuteReader (System.Data.CommandBehavior cb);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDataReader</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="cb" Type="System.Data.CommandBehavior" />
</Parameters>
<Docs>
<param name="cb">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbCommand.Parameters">
<MemberSignature Language="C#" Value="System.Data.IDataParameterCollection System.Data.IDbCommand.Parameters { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDataParameterCollection</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbCommand.Transaction">
<MemberSignature Language="C#" Value="System.Data.IDbTransaction System.Data.IDbCommand.Transaction { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbTransaction</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.ICloneable.Clone">
<MemberSignature Language="C#" Value="object ICloneable.Clone ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Transaction">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlTransaction Transaction { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlTransaction</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.IDbTransaction" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="UpdatedRowSource">
<MemberSignature Language="C#" Value="public System.Data.UpdateRowSource UpdatedRowSource { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.UpdateRowSource</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.UpdateRowSource" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,218 +0,0 @@
<Type Name="NpgsqlCommandBuilder" FullName="Npgsql.NpgsqlCommandBuilder">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlCommandBuilder : System.ComponentModel.Component" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>[00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 2B 3C 59 0B 2A 4E 3D 34 7E 68 78 DC 0F F4 D2 1E B0 56 A5 04 20 25 0C 66 17 04 43 30 70 1D 35 C9 80 78 A5 DF 97 A6 2D 83 C9 A2 DB 2D 07 25 23 A8 FC 49 13 98 25 4C 6B 89 32 9B 8C 1D CE F4 3A 1E 7A A1 61 53 BC EA 2A E9 A4 71 14 56 24 82 6F 60 D7 C8 E7 1C D0 25 B5 54 A0 17 7B D9 35 A7 80 96 29 F0 A7 AF C7 78 EB B4 AD 03 3E 1B F5 12 C1 A9 C6 CE EA 26 B0 77 BC 46 CA C9 38 00 43 5E 77 EE]</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.ComponentModel.Component</BaseTypeName>
</Base>
<Interfaces>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommandBuilder ();" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCommandBuilder (Npgsql.NpgsqlDataAdapter adapter);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="adapter" Type="Npgsql.NpgsqlDataAdapter" />
</Parameters>
<Docs>
<param name="adapter">a <see cref="T:Npgsql.NpgsqlDataAdapter" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="DataAdapter">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlDataAdapter DataAdapter { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlDataAdapter</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlDataAdapter" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="DeriveParameters">
<MemberSignature Language="C#" Value="public static void DeriveParameters (Npgsql.NpgsqlCommand command);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="command" Type="Npgsql.NpgsqlCommand" />
</Parameters>
<Docs>
<param name="command">a <see cref="T:Npgsql.NpgsqlCommand" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Dispose">
<MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="disposing" Type="System.Boolean" />
</Parameters>
<Docs>
<param name="disposing">a <see cref="T:System.Boolean" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetDeleteCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand GetDeleteCommand (System.Data.DataRow row);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="row" Type="System.Data.DataRow" />
</Parameters>
<Docs>
<param name="row">a <see cref="T:System.Data.DataRow" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlCommand" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetInsertCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand GetInsertCommand (System.Data.DataRow row);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="row" Type="System.Data.DataRow" />
</Parameters>
<Docs>
<param name="row">a <see cref="T:System.Data.DataRow" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlCommand" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetUpdateCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand GetUpdateCommand (System.Data.DataRow row);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="row" Type="System.Data.DataRow" />
</Parameters>
<Docs>
<param name="row">a <see cref="T:System.Data.DataRow" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlCommand" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="QuotePrefix">
<MemberSignature Language="C#" Value="public string QuotePrefix { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="QuoteSuffix">
<MemberSignature Language="C#" Value="public string QuoteSuffix { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="RefreshSchema">
<MemberSignature Language="C#" Value="public void RefreshSchema ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,679 +0,0 @@
<Type Name="NpgsqlConnection" FullName="Npgsql.NpgsqlConnection">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlConnection : System.ComponentModel.Component, ICloneable, System.Data.IDbConnection" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.ComponentModel.Component</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Data.IDbConnection</InterfaceName>
</Interface>
<Interface>
<InterfaceName>System.ICloneable</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>Represents an open connection to a PostgreSQL database.</summary>
<remarks>
<para>
This represents a unique connection to a PostgreSQL database backend. The connection is used in conjunction with other classes
in the <see cref="N:Npgsql" /> provider like <see cref="T:Npgsql.NpgsqlCommand" />, <see cref="T:Npgsql.NpgsqlDataReader" />, and
<see cref="T:Npgsql.NpgsqlDataAdapter" /> to fetch, add, update, or delete data in the database.
</para>
</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlConnection ();" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlConnection (string ConnectionString);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="ConnectionString" Type="System.String" />
</Parameters>
<Docs>
<param name="ConnectionString">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="BackendProtocolVersion">
<MemberSignature Language="C#" Value="public Npgsql.ProtocolVersion BackendProtocolVersion { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>Npgsql.ProtocolVersion</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="BeginTransaction">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlTransaction BeginTransaction ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlTransaction</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlTransaction" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="BeginTransaction">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlTransaction BeginTransaction (System.Data.IsolationLevel level);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlTransaction</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="level" Type="System.Data.IsolationLevel" />
</Parameters>
<Docs>
<param name="level">a <see cref="T:System.Data.IsolationLevel" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlTransaction" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="CertificateSelectionCallback">
<MemberSignature Language="C#" Value="public event Mono.Security.Protocol.Tls.CertificateSelectionCallback CertificateSelectionCallback;" />
<MemberType>Event</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Mono.Security.Protocol.Tls.CertificateSelectionCallback</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="CertificateValidationCallback">
<MemberSignature Language="C#" Value="public event Mono.Security.Protocol.Tls.CertificateValidationCallback CertificateValidationCallback;" />
<MemberType>Event</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Mono.Security.Protocol.Tls.CertificateValidationCallback</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="ChangeDatabase">
<MemberSignature Language="C#" Value="public void ChangeDatabase (string dbName);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="dbName" Type="System.String" />
</Parameters>
<Docs>
<param name="dbName">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ClearAllPools">
<MemberSignature Language="C#" Value="public void ClearAllPools ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="ClearPool">
<MemberSignature Language="C#" Value="public void ClearPool ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Clone">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlConnection Clone ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlConnection</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Close">
<MemberSignature Language="C#" Value="public void Close ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ConnectionLifeTime">
<MemberSignature Language="C#" Value="public int ConnectionLifeTime { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="ConnectionString">
<MemberSignature Language="C#" Value="public string ConnectionString { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ConnectionTimeout">
<MemberSignature Language="C#" Value="public int ConnectionTimeout { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="CreateCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand CreateCommand ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlCommand" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Database">
<MemberSignature Language="C#" Value="public string Database { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Dispose">
<MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="disposing" Type="System.Boolean" />
</Parameters>
<Docs>
<param name="disposing">a <see cref="T:System.Boolean" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetSchema">
<MemberSignature Language="C#" Value="public System.Data.DataTable GetSchema ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.DataTable</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="GetSchema">
<MemberSignature Language="C#" Value="public System.Data.DataTable GetSchema (string collectionName);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.DataTable</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="collectionName" Type="System.String" />
</Parameters>
<Docs>
<param name="collectionName">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="GetSchema">
<MemberSignature Language="C#" Value="public System.Data.DataTable GetSchema (string collectionName, string[] restrictions);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.DataTable</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="collectionName" Type="System.String" />
<Parameter Name="restrictions" Type="System.String[]" />
</Parameters>
<Docs>
<param name="collectionName">To be added.</param>
<param name="restrictions">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Host">
<MemberSignature Language="C#" Value="public string Host { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(true)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Notice">
<MemberSignature Language="C#" Value="public event Npgsql.NoticeEventHandler Notice;" />
<MemberType>Event</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NoticeEventHandler</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Notification">
<MemberSignature Language="C#" Value="public event Npgsql.NotificationEventHandler Notification;" />
<MemberType>Event</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NotificationEventHandler</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Open">
<MemberSignature Language="C#" Value="public void Open ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>Connect to the PostgreSQL database backend</summary>
<remarks>To be added</remarks>
<example>
<para>
To establish a connection to a server located at ip 127.0.0.1, port 5432, as the user joe,
with the password secret, using the database joedata, you use the NpgsqlConnection as:
</para>
<code lang="C#">
using System;
using System.Data;
using Npgsql;
public class NpgsqlConnDemo
{
public static void Main(String[] args)
{
// Create a new connection object
NpgsqlConnection conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
// Open the connection
conn.Open();
// Close it
conn.Close();
}
}
</code>
</example>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Port">
<MemberSignature Language="C#" Value="public int Port { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(true)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="PrivateKeySelectionCallback">
<MemberSignature Language="C#" Value="public event Mono.Security.Protocol.Tls.PrivateKeySelectionCallback PrivateKeySelectionCallback;" />
<MemberType>Event</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Mono.Security.Protocol.Tls.PrivateKeySelectionCallback</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="ServerVersion">
<MemberSignature Language="C#" Value="public Npgsql.ServerVersion ServerVersion { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>Npgsql.ServerVersion</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="SSL">
<MemberSignature Language="C#" Value="public bool SSL { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(true)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="State">
<MemberSignature Language="C#" Value="public System.Data.ConnectionState State { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.ConnectionState</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.ConnectionState" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="SyncNotification">
<MemberSignature Language="C#" Value="public bool SyncNotification { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbConnection.BeginTransaction">
<MemberSignature Language="C#" Value="System.Data.IDbTransaction IDbConnection.BeginTransaction ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbTransaction</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbConnection.BeginTransaction">
<MemberSignature Language="C#" Value="System.Data.IDbTransaction IDbConnection.BeginTransaction (System.Data.IsolationLevel level);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbTransaction</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="level" Type="System.Data.IsolationLevel" />
</Parameters>
<Docs>
<param name="level">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbConnection.CreateCommand">
<MemberSignature Language="C#" Value="System.Data.IDbCommand IDbConnection.CreateCommand ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.ICloneable.Clone">
<MemberSignature Language="C#" Value="object ICloneable.Clone ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
</Members>
</Type>
@@ -1,362 +0,0 @@
<Type Name="NpgsqlDataAdapter" FullName="Npgsql.NpgsqlDataAdapter">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlDataAdapter : System.Data.Common.DbDataAdapter" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Data.Common.DbDataAdapter</BaseTypeName>
</Base>
<Interfaces>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlDataAdapter ();" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlDataAdapter (Npgsql.NpgsqlCommand selectCommand);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="selectCommand" Type="Npgsql.NpgsqlCommand" />
</Parameters>
<Docs>
<param name="selectCommand">a <see cref="T:Npgsql.NpgsqlCommand" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlDataAdapter (string selectCommandText, Npgsql.NpgsqlConnection selectConnection);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="selectCommandText" Type="System.String" />
<Parameter Name="selectConnection" Type="Npgsql.NpgsqlConnection" />
</Parameters>
<Docs>
<param name="selectCommandText">a <see cref="T:System.String" /></param>
<param name="selectConnection">a <see cref="T:Npgsql.NpgsqlConnection" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlDataAdapter (string selectCommandText, string selectConnectionString);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="selectCommandText" Type="System.String" />
<Parameter Name="selectConnectionString" Type="System.String" />
</Parameters>
<Docs>
<param name="selectCommandText">a <see cref="T:System.String" /></param>
<param name="selectConnectionString">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="CreateRowUpdatedEvent">
<MemberSignature Language="C#" Value="protected override System.Data.Common.RowUpdatedEventArgs CreateRowUpdatedEvent (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Data.Common.RowUpdatedEventArgs</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="dataRow" Type="System.Data.DataRow" />
<Parameter Name="command" Type="System.Data.IDbCommand" />
<Parameter Name="statementType" Type="System.Data.StatementType" />
<Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
</Parameters>
<Docs>
<param name="dataRow">a <see cref="T:System.Data.DataRow" /></param>
<param name="command">a <see cref="T:System.Data.IDbCommand" /></param>
<param name="statementType">a <see cref="T:System.Data.StatementType" /></param>
<param name="tableMapping">a <see cref="T:System.Data.Common.DataTableMapping" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Data.Common.RowUpdatedEventArgs" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="CreateRowUpdatingEvent">
<MemberSignature Language="C#" Value="protected override System.Data.Common.RowUpdatingEventArgs CreateRowUpdatingEvent (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Data.Common.RowUpdatingEventArgs</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="dataRow" Type="System.Data.DataRow" />
<Parameter Name="command" Type="System.Data.IDbCommand" />
<Parameter Name="statementType" Type="System.Data.StatementType" />
<Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
</Parameters>
<Docs>
<param name="dataRow">a <see cref="T:System.Data.DataRow" /></param>
<param name="command">a <see cref="T:System.Data.IDbCommand" /></param>
<param name="statementType">a <see cref="T:System.Data.StatementType" /></param>
<param name="tableMapping">a <see cref="T:System.Data.Common.DataTableMapping" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Data.Common.RowUpdatingEventArgs" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="DeleteCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand DeleteCommand { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlCommand" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="InsertCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand InsertCommand { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlCommand" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="OnRowUpdated">
<MemberSignature Language="C#" Value="protected override void OnRowUpdated (System.Data.Common.RowUpdatedEventArgs value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Data.Common.RowUpdatedEventArgs" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Data.Common.RowUpdatedEventArgs" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="OnRowUpdating">
<MemberSignature Language="C#" Value="protected override void OnRowUpdating (System.Data.Common.RowUpdatingEventArgs value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Data.Common.RowUpdatingEventArgs" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Data.Common.RowUpdatingEventArgs" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="RowUpdated">
<MemberSignature Language="C#" Value="public event Npgsql.NpgsqlRowUpdatedEventHandler RowUpdated;" />
<MemberType>Event</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlRowUpdatedEventHandler</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="RowUpdating">
<MemberSignature Language="C#" Value="public event Npgsql.NpgsqlRowUpdatingEventHandler RowUpdating;" />
<MemberType>Event</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlRowUpdatingEventHandler</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="SelectCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand SelectCommand { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlCommand" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="System.Data.IDataAdapter.TableMappings">
<MemberSignature Language="C#" Value="System.Data.ITableMappingCollection System.Data.IDataAdapter.TableMappings { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.ITableMappingCollection</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbDataAdapter.DeleteCommand">
<MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.DeleteCommand { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbCommand</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbDataAdapter.InsertCommand">
<MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.InsertCommand { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbCommand</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbDataAdapter.SelectCommand">
<MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.SelectCommand { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbCommand</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDbDataAdapter.UpdateCommand">
<MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.UpdateCommand { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbCommand</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="UpdateCommand">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlCommand UpdateCommand { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlCommand</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlCommand" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,803 +0,0 @@
<Type Name="NpgsqlDataReader" FullName="Npgsql.NpgsqlDataReader">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlDataReader : System.Collections.IEnumerable, System.Data.IDataReader" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Collections.IEnumerable</InterfaceName>
</Interface>
<Interface>
<InterfaceName>System.Data.IDataReader</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Close">
<MemberSignature Language="C#" Value="public void Close ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Depth">
<MemberSignature Language="C#" Value="public int Depth { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Dispose">
<MemberSignature Language="C#" Value="public void Dispose ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Dispose">
<MemberSignature Language="C#" Value="protected void Dispose (bool disposing);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="disposing" Type="System.Boolean" />
</Parameters>
<Docs>
<param name="disposing">a <see cref="T:System.Boolean" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="FieldCount">
<MemberSignature Language="C#" Value="public int FieldCount { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetBoolean">
<MemberSignature Language="C#" Value="public bool GetBoolean (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetByte">
<MemberSignature Language="C#" Value="public byte GetByte (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Byte</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Byte" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetBytes">
<MemberSignature Language="C#" Value="public long GetBytes (int i, long fieldOffset, byte[] buffer, int bufferoffset, int length);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int64</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
<Parameter Name="fieldOffset" Type="System.Int64" />
<Parameter Name="buffer" Type="System.Byte[]" />
<Parameter Name="bufferoffset" Type="System.Int32" />
<Parameter Name="length" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<param name="fieldOffset">a <see cref="T:System.Int64" /></param>
<param name="buffer">a <see cref="T:System.Byte[]" /></param>
<param name="bufferoffset">a <see cref="T:System.Int32" /></param>
<param name="length">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int64" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetChar">
<MemberSignature Language="C#" Value="public char GetChar (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Char</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Char" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetChars">
<MemberSignature Language="C#" Value="public long GetChars (int i, long fieldoffset, char[] buffer, int bufferoffset, int length);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int64</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
<Parameter Name="fieldoffset" Type="System.Int64" />
<Parameter Name="buffer" Type="System.Char[]" />
<Parameter Name="bufferoffset" Type="System.Int32" />
<Parameter Name="length" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<param name="fieldoffset">a <see cref="T:System.Int64" /></param>
<param name="buffer">a <see cref="T:System.Char[]" /></param>
<param name="bufferoffset">a <see cref="T:System.Int32" /></param>
<param name="length">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int64" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetData">
<MemberSignature Language="C#" Value="public System.Data.IDataReader GetData (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Data.IDataReader</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Data.IDataReader" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetDataTypeName">
<MemberSignature Language="C#" Value="public string GetDataTypeName (int Index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.String" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetDataTypeOID">
<MemberSignature Language="C#" Value="public string GetDataTypeOID (int Index);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="GetDateTime">
<MemberSignature Language="C#" Value="public DateTime GetDateTime (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.DateTime</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.DateTime" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetDecimal">
<MemberSignature Language="C#" Value="public decimal GetDecimal (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Decimal</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Decimal" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetDouble">
<MemberSignature Language="C#" Value="public double GetDouble (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Double</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Double" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetFieldDbType">
<MemberSignature Language="C#" Value="public System.Data.DbType GetFieldDbType (int Index);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.DbType</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="GetFieldNpgsqlDbType">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlDbType GetFieldNpgsqlDbType (int Index);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="GetFieldType">
<MemberSignature Language="C#" Value="public Type GetFieldType (int Index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Type</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Type" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetFloat">
<MemberSignature Language="C#" Value="public float GetFloat (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Single</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Single" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetGuid">
<MemberSignature Language="C#" Value="public Guid GetGuid (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Guid</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Guid" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetInt16">
<MemberSignature Language="C#" Value="public short GetInt16 (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int16</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int16" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetInt32">
<MemberSignature Language="C#" Value="public int GetInt32 (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetInt64">
<MemberSignature Language="C#" Value="public long GetInt64 (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int64</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int64" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetName">
<MemberSignature Language="C#" Value="public string GetName (int Index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.String" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetOrdinal">
<MemberSignature Language="C#" Value="public int GetOrdinal (string Name);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Name" Type="System.String" />
</Parameters>
<Docs>
<param name="Name">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetSchemaTable">
<MemberSignature Language="C#" Value="public System.Data.DataTable GetSchemaTable ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Data.DataTable</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:System.Data.DataTable" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetString">
<MemberSignature Language="C#" Value="public string GetString (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.String" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetValue">
<MemberSignature Language="C#" Value="public object GetValue (int Index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Object" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetValues">
<MemberSignature Language="C#" Value="public int GetValues (object[] Values);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Values" Type="System.Object[]" />
</Parameters>
<Docs>
<param name="Values">a <see cref="T:System.Object[]" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="HasRows">
<MemberSignature Language="C#" Value="public bool HasRows { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="IsClosed">
<MemberSignature Language="C#" Value="public bool IsClosed { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Boolean" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="IsDBNull">
<MemberSignature Language="C#" Value="public bool IsDBNull (int i);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public object this[int i] { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="i" Type="System.Int32" />
</Parameters>
<Docs>
<param name="i">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<value>a <see cref="T:System.Object" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public object this[string name] { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
</Parameters>
<Docs>
<param name="name">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<value>a <see cref="T:System.Object" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="NextResult">
<MemberSignature Language="C#" Value="public bool NextResult ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Read">
<MemberSignature Language="C#" Value="public bool Read ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ReaderClosed">
<MemberSignature Language="C#" Value="public event EventHandler ReaderClosed;" />
<MemberType>Event</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.EventHandler</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="RecordsAffected">
<MemberSignature Language="C#" Value="public int RecordsAffected { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="System.Collections.IEnumerable.GetEnumerator">
<MemberSignature Language="C#" Value="System.Collections.IEnumerator IEnumerable.GetEnumerator ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Collections.IEnumerator</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
</Members>
</Type>
@@ -1,224 +0,0 @@
<Type Name="NpgsqlError" FullName="Npgsql.NpgsqlError">
<TypeSignature Language="C#" Value="public sealed class NpgsqlError" Maintainer="auto" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>[00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 2B 3C 59 0B 2A 4E 3D 34 7E 68 78 DC 0F F4 D2 1E B0 56 A5 04 20 25 0C 66 17 04 43 30 70 1D 35 C9 80 78 A5 DF 97 A6 2D 83 C9 A2 DB 2D 07 25 23 A8 FC 49 13 98 25 4C 6B 89 32 9B 8C 1D CE F4 3A 1E 7A A1 61 53 BC EA 2A E9 A4 71 14 56 24 82 6F 60 D7 C8 E7 1C D0 25 B5 54 A0 17 7B D9 35 A7 80 96 29 F0 A7 AF C7 78 EB B4 AD 03 3E 1B F5 12 C1 A9 C6 CE EA 26 B0 77 BC 46 CA C9 38 00 43 5E 77 EE]</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Code">
<MemberSignature Language="C#" Value="public string Code { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Detail">
<MemberSignature Language="C#" Value="public string Detail { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ErrorSql">
<MemberSignature Language="C#" Value="public string ErrorSql { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="File">
<MemberSignature Language="C#" Value="public string File { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Hint">
<MemberSignature Language="C#" Value="public string Hint { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Line">
<MemberSignature Language="C#" Value="public string Line { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Message">
<MemberSignature Language="C#" Value="public string Message { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Position">
<MemberSignature Language="C#" Value="public string Position { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Routine">
<MemberSignature Language="C#" Value="public string Routine { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Severity">
<MemberSignature Language="C#" Value="public string Severity { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:System.String" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Where">
<MemberSignature Language="C#" Value="public string Where { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,73 +0,0 @@
<Type Name="NpgsqlEventLog" FullName="Npgsql.NpgsqlEventLog">
<TypeSignature Language="C#" Value="public class NpgsqlEventLog" Maintainer="auto" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="EchoMessages">
<MemberSignature Language="C#" Value="public static bool EchoMessages { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Boolean" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Level">
<MemberSignature Language="C#" Value="public static Npgsql.LogLevel Level { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.LogLevel</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.LogLevel" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="LogName">
<MemberSignature Language="C#" Value="public static string LogName { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,283 +0,0 @@
<Type Name="NpgsqlException" FullName="Npgsql.NpgsqlException">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlException : ApplicationException" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.ApplicationException</BaseTypeName>
</Base>
<Interfaces>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="BaseMessage">
<MemberSignature Language="C#" Value="public string BaseMessage { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Code">
<MemberSignature Language="C#" Value="public string Code { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Detail">
<MemberSignature Language="C#" Value="public string Detail { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Errors">
<MemberSignature Language="C#" Value="public System.Collections.IList Errors { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Collections.IList</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Collections.IList" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ErrorSql">
<MemberSignature Language="C#" Value="public string ErrorSql { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="File">
<MemberSignature Language="C#" Value="public string File { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetObjectData">
<MemberSignature Language="C#" Value="public override void GetObjectData (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="info" Type="System.Runtime.Serialization.SerializationInfo" />
<Parameter Name="context" Type="System.Runtime.Serialization.StreamingContext" />
</Parameters>
<Docs>
<param name="info">To be added.</param>
<param name="context">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Hint">
<MemberSignature Language="C#" Value="public string Hint { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlError this[int Index] { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlError</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlError" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Line">
<MemberSignature Language="C#" Value="public string Line { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Position">
<MemberSignature Language="C#" Value="public string Position { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Routine">
<MemberSignature Language="C#" Value="public string Routine { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Severity">
<MemberSignature Language="C#" Value="public string Severity { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<returns>a <see cref="T:System.String" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Where">
<MemberSignature Language="C#" Value="public string Where { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,33 +0,0 @@
<Type Name="NpgsqlNoticeEventArgs" FullName="Npgsql.NpgsqlNoticeEventArgs">
<TypeSignature Language="C#" Value="public class NpgsqlNoticeEventArgs : EventArgs" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.EventArgs</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName="Notice">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlError Notice;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlError</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,56 +0,0 @@
<Type Name="NpgsqlNotificationEventArgs" FullName="Npgsql.NpgsqlNotificationEventArgs">
<TypeSignature Language="C#" Maintainer="auto" Value="public class NpgsqlNotificationEventArgs : EventArgs" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.EventArgs</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Condition">
<MemberSignature Language="C#" Value="public string Condition;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters>
</Parameters>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="PID">
<MemberSignature Language="C#" Value="public int PID;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
</Parameters>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,540 +0,0 @@
<Type Name="NpgsqlParameter" FullName="Npgsql.NpgsqlParameter">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlParameter : MarshalByRefObject, ICloneable, System.Data.IDbDataParameter" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.MarshalByRefObject</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Data.IDbDataParameter</InterfaceName>
</Interface>
<Interface>
<InterfaceName>System.ICloneable</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter ();" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType);" />
<MemberType>Constructor</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, System.Data.DbType parameterType);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="System.Data.DbType" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="parameterType">a <see cref="T:System.Data.DbType" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, object value);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType, int size);" />
<MemberType>Constructor</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
<Parameter Name="size" Type="System.Int32" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<param name="size">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, System.Data.DbType parameterType, int size);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="System.Data.DbType" />
<Parameter Name="size" Type="System.Int32" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="parameterType">a <see cref="T:System.Data.DbType" /></param>
<param name="size">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType, int size, string sourceColumn);" />
<MemberType>Constructor</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
<Parameter Name="size" Type="System.Int32" />
<Parameter Name="sourceColumn" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<param name="size">To be added.</param>
<param name="sourceColumn">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, System.Data.DbType parameterType, int size, string sourceColumn);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="System.Data.DbType" />
<Parameter Name="size" Type="System.Int32" />
<Parameter Name="sourceColumn" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="parameterType">a <see cref="T:System.Data.DbType" /></param>
<param name="size">a <see cref="T:System.Int32" /></param>
<param name="sourceColumn">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType, int size, string sourceColumn, System.Data.ParameterDirection direction, bool isNullable, byte precision, byte scale, System.Data.DataRowVersion sourceVersion, object value);" />
<MemberType>Constructor</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
<Parameter Name="size" Type="System.Int32" />
<Parameter Name="sourceColumn" Type="System.String" />
<Parameter Name="direction" Type="System.Data.ParameterDirection" />
<Parameter Name="isNullable" Type="System.Boolean" />
<Parameter Name="precision" Type="System.Byte" />
<Parameter Name="scale" Type="System.Byte" />
<Parameter Name="sourceVersion" Type="System.Data.DataRowVersion" />
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<param name="size">To be added.</param>
<param name="sourceColumn">To be added.</param>
<param name="direction">To be added.</param>
<param name="isNullable">To be added.</param>
<param name="precision">To be added.</param>
<param name="scale">To be added.</param>
<param name="sourceVersion">To be added.</param>
<param name="value">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlParameter (string parameterName, System.Data.DbType parameterType, int size, string sourceColumn, System.Data.ParameterDirection direction, bool isNullable, byte precision, byte scale, System.Data.DataRowVersion sourceVersion, object value);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="System.Data.DbType" />
<Parameter Name="size" Type="System.Int32" />
<Parameter Name="sourceColumn" Type="System.String" />
<Parameter Name="direction" Type="System.Data.ParameterDirection" />
<Parameter Name="isNullable" Type="System.Boolean" />
<Parameter Name="precision" Type="System.Byte" />
<Parameter Name="scale" Type="System.Byte" />
<Parameter Name="sourceVersion" Type="System.Data.DataRowVersion" />
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="parameterType">a <see cref="T:System.Data.DbType" /></param>
<param name="size">a <see cref="T:System.Int32" /></param>
<param name="sourceColumn">a <see cref="T:System.String" /></param>
<param name="direction">a <see cref="T:System.Data.ParameterDirection" /></param>
<param name="isNullable">a <see cref="T:System.Boolean" /></param>
<param name="precision">a <see cref="T:System.Byte" /></param>
<param name="scale">a <see cref="T:System.Byte" /></param>
<param name="sourceVersion">a <see cref="T:System.Data.DataRowVersion" /></param>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="DbType">
<MemberSignature Language="C#" Value="public System.Data.DbType DbType { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.DbType</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.DbType" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(System.Data.DbType.String)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.All)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="Direction">
<MemberSignature Language="C#" Value="public System.Data.ParameterDirection Direction { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.ParameterDirection</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.ParameterDirection" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(System.Data.ParameterDirection.Input)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="IsNullable">
<MemberSignature Language="C#" Value="public bool IsNullable { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Boolean" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="NpgsqlDbType">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlDbType NpgsqlDbType { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(NpgsqlTypes.NpgsqlDbType.Text)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.RefreshProperties(System.ComponentModel.RefreshProperties.All)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="ParameterName">
<MemberSignature Language="C#" Value="public string ParameterName { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue("")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="Precision">
<MemberSignature Language="C#" Value="public byte Precision { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Byte</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Byte" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(0)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="Scale">
<MemberSignature Language="C#" Value="public byte Scale { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Byte</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Byte" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(0)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="Size">
<MemberSignature Language="C#" Value="public int Size { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(0)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="SourceColumn">
<MemberSignature Language="C#" Value="public string SourceColumn { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.String" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="SourceVersion">
<MemberSignature Language="C#" Value="public System.Data.DataRowVersion SourceVersion { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.DataRowVersion</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.DataRowVersion" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.DefaultValue(System.Data.DataRowVersion.Current)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
</Attributes>
</Member>
<Member MemberName="System.ICloneable.Clone">
<MemberSignature Language="C#" Value="object ICloneable.Clone ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Value">
<MemberSignature Language="C#" Value="public object Value { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Object" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute>
<AttributeName>System.ComponentModel.Category("Data")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter))</AttributeName>
</Attribute>
</Attributes>
</Member>
</Members>
</Type>
@@ -1,555 +0,0 @@
<Type Name="NpgsqlParameterCollection" FullName="Npgsql.NpgsqlParameterCollection">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlParameterCollection : MarshalByRefObject, System.Data.IDataParameterCollection" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.MarshalByRefObject</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Data.IDataParameterCollection</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter Add (Npgsql.NpgsqlParameter value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="Npgsql.NpgsqlParameter" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:Npgsql.NpgsqlParameter" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlParameter" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public int Add (object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter Add (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter Add (string parameterName, object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:Npgsql.NpgsqlParameter" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter Add (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType, int size);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
<Parameter Name="size" Type="System.Int32" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<param name="size">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter Add (string parameterName, NpgsqlTypes.NpgsqlDbType parameterType, int size, string sourceColumn);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameterType" Type="NpgsqlTypes.NpgsqlDbType" />
<Parameter Name="size" Type="System.Int32" />
<Parameter Name="sourceColumn" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameterType">To be added.</param>
<param name="size">To be added.</param>
<param name="sourceColumn">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="Clear">
<MemberSignature Language="C#" Value="public void Clear ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Contains">
<MemberSignature Language="C#" Value="public bool Contains (object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Contains">
<MemberSignature Language="C#" Value="public bool Contains (string parameterName);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Boolean" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="CopyTo">
<MemberSignature Language="C#" Value="public void CopyTo (Array array, int index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="array" Type="System.Array" />
<Parameter Name="index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="array">a <see cref="T:System.Array" /></param>
<param name="index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Count">
<MemberSignature Language="C#" Value="public int Count { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Int32" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="IndexOf">
<MemberSignature Language="C#" Value="public int IndexOf (object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="IndexOf">
<MemberSignature Language="C#" Value="public int IndexOf (string parameterName);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<returns>a <see cref="T:System.Int32" /></returns>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Insert">
<MemberSignature Language="C#" Value="public void Insert (int index, object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="index" Type="System.Int32" />
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="index">a <see cref="T:System.Int32" /></param>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter this[int index] { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlParameter" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlParameter this[string parameterName] { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlParameter</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlParameter" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Remove">
<MemberSignature Language="C#" Value="public void Remove (object value);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="value" Type="System.Object" />
</Parameters>
<Docs>
<param name="value">a <see cref="T:System.Object" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="RemoveAt">
<MemberSignature Language="C#" Value="public void RemoveAt (int index);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="index">a <see cref="T:System.Int32" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="RemoveAt">
<MemberSignature Language="C#" Value="public void RemoveAt (string parameterName);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">a <see cref="T:System.String" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="System.Collections.ICollection.IsSynchronized">
<MemberSignature Language="C#" Value="bool System.Collections.ICollection.IsSynchronized { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Collections.ICollection.SyncRoot">
<MemberSignature Language="C#" Value="object System.Collections.ICollection.SyncRoot { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Collections.IEnumerable.GetEnumerator">
<MemberSignature Language="C#" Value="System.Collections.IEnumerator IEnumerable.GetEnumerator ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Collections.IEnumerator</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Collections.IList.IsFixedSize">
<MemberSignature Language="C#" Value="bool System.Collections.IList.IsFixedSize { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Collections.IList.IsReadOnly">
<MemberSignature Language="C#" Value="bool System.Collections.IList.IsReadOnly { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Collections.IList.Item">
<MemberSignature Language="C#" Value="object System.Collections.IList.Item[int index] { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="index">To be added.</param>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="System.Data.IDataParameterCollection.Item">
<MemberSignature Language="C#" Value="object System.Data.IDataParameterCollection.Item[string parameterName] { set; get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="TryGetValue">
<MemberSignature Language="C#" Value="public bool TryGetValue (string parameterName, out Npgsql.NpgsqlParameter parameter);" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="parameterName" Type="System.String" />
<Parameter Name="parameter" Type="Npgsql.NpgsqlParameter&amp;" RefType="out" />
</Parameters>
<Docs>
<param name="parameterName">To be added.</param>
<param name="parameter">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
</Member>
</Members>
</Type>
@@ -1,28 +0,0 @@
<Type Name="NpgsqlRowUpdatedEventHandler" FullName="Npgsql.NpgsqlRowUpdatedEventHandler">
<TypeSignature Language="C#" Maintainer="auto" Value="public delegate void NpgsqlRowUpdatedEventHandler(object sender, NpgsqlRowUpdatedEventArgs e);" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>[00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 2B 3C 59 0B 2A 4E 3D 34 7E 68 78 DC 0F F4 D2 1E B0 56 A5 04 20 25 0C 66 17 04 43 30 70 1D 35 C9 80 78 A5 DF 97 A6 2D 83 C9 A2 DB 2D 07 25 23 A8 FC 49 13 98 25 4C 6B 89 32 9B 8C 1D CE F4 3A 1E 7A A1 61 53 BC EA 2A E9 A4 71 14 56 24 82 6F 60 D7 C8 E7 1C D0 25 B5 54 A0 17 7B D9 35 A7 80 96 29 F0 A7 AF C7 78 EB B4 AD 03 3E 1B F5 12 C1 A9 C6 CE EA 26 B0 77 BC 46 CA C9 38 00 43 5E 77 EE]</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Docs>
<param name="sender">To be added.</param>
<param name="e">To be added.</param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members />
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="sender" Type="System.Object" />
<Parameter Name="e" Type="NpgsqlRowUpdatedEventArgs" />
</Parameters>
</Type>
@@ -1,28 +0,0 @@
<Type Name="NpgsqlRowUpdatingEventHandler" FullName="Npgsql.NpgsqlRowUpdatingEventHandler">
<TypeSignature Language="C#" Maintainer="auto" Value="public delegate void NpgsqlRowUpdatingEventHandler(object sender, NpgsqlRowUpdatingEventArgs e);" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>[00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 2B 3C 59 0B 2A 4E 3D 34 7E 68 78 DC 0F F4 D2 1E B0 56 A5 04 20 25 0C 66 17 04 43 30 70 1D 35 C9 80 78 A5 DF 97 A6 2D 83 C9 A2 DB 2D 07 25 23 A8 FC 49 13 98 25 4C 6B 89 32 9B 8C 1D CE F4 3A 1E 7A A1 61 53 BC EA 2A E9 A4 71 14 56 24 82 6F 60 D7 C8 E7 1C D0 25 B5 54 A0 17 7B D9 35 A7 80 96 29 F0 A7 AF C7 78 EB B4 AD 03 3E 1B F5 12 C1 A9 C6 CE EA 26 B0 77 BC 46 CA C9 38 00 43 5E 77 EE]</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.Delegate</BaseTypeName>
</Base>
<Docs>
<param name="sender">To be added.</param>
<param name="e">To be added.</param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members />
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="sender" Type="System.Object" />
<Parameter Name="e" Type="NpgsqlRowUpdatingEventArgs" />
</Parameters>
</Type>
@@ -1,140 +0,0 @@
<Type Name="NpgsqlTransaction" FullName="Npgsql.NpgsqlTransaction">
<TypeSignature Language="C#" Maintainer="auto" Value="public sealed class NpgsqlTransaction : MarshalByRefObject, System.Data.IDbTransaction" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
<Base>
<BaseTypeName>System.MarshalByRefObject</BaseTypeName>
</Base>
<Interfaces>
<Interface>
<InterfaceName>System.Data.IDbTransaction</InterfaceName>
</Interface>
</Interfaces>
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName="Commit">
<MemberSignature Language="C#" Value="public void Commit ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Connection">
<MemberSignature Language="C#" Value="public Npgsql.NpgsqlConnection Connection { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlConnection</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:Npgsql.NpgsqlConnection" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Dispose">
<MemberSignature Language="C#" Value="public void Dispose ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Finalize">
<MemberSignature Language="C#" Value="~NpgsqlTransaction ();" />
<MemberType>Method</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Member>
<Member MemberName="IsolationLevel">
<MemberSignature Language="C#" Value="public System.Data.IsolationLevel IsolationLevel { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Data.IsolationLevel</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<value>a <see cref="T:System.Data.IsolationLevel" /></value>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Rollback">
<MemberSignature Language="C#" Value="public void Rollback ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="System.Data.IDbTransaction.Connection">
<MemberSignature Language="C#" Value="System.Data.IDbConnection System.Data.IDbTransaction.Connection { get; }" />
<MemberType>Property</MemberType>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Data.IDbConnection</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
</Member>
</Members>
</Type>
@@ -1,59 +0,0 @@
<Type Name="ProtocolVersion" FullName="Npgsql.ProtocolVersion">
<TypeSignature Language="C#" Value="public enum ProtocolVersion" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Enum</BaseTypeName>
</Base>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName="Unknown">
<MemberSignature Language="C#" Value="Unknown" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.ProtocolVersion</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Version2">
<MemberSignature Language="C#" Value="Version2" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.ProtocolVersion</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Version3">
<MemberSignature Language="C#" Value="Version3" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.ProtocolVersion</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,284 +0,0 @@
<Type Name="ServerVersion" FullName="Npgsql.ServerVersion">
<TypeSignature Language="C#" Value="public sealed class ServerVersion" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName="Equals">
<MemberSignature Language="C#" Value="public override bool Equals (object O);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="O" Type="System.Object" />
</Parameters>
<Docs>
<param name="O">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetHashCode">
<MemberSignature Language="C#" Value="public override int GetHashCode ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Major">
<MemberSignature Language="C#" Value="public int Major { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Minor">
<MemberSignature Language="C#" Value="public int Minor { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_Equality">
<MemberSignature Language="C#" Value="public static bool op_Equality (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_GreaterThan">
<MemberSignature Language="C#" Value="public static bool op_GreaterThan (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_GreaterThanOrEqual">
<MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_Inequality">
<MemberSignature Language="C#" Value="public static bool op_Inequality (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_LessThan">
<MemberSignature Language="C#" Value="public static bool op_LessThan (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_LessThanOrEqual">
<MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (Npgsql.ServerVersion One, Npgsql.ServerVersion TheOther);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="One" Type="Npgsql.ServerVersion" />
<Parameter Name="TheOther" Type="Npgsql.ServerVersion" />
</Parameters>
<Docs>
<param name="One">To be added.</param>
<param name="TheOther">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Patch">
<MemberSignature Language="C#" Value="public int Patch { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ProtocolVersion2">
<MemberSignature Language="C#" Value="public static readonly int ProtocolVersion2 = 131072;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>131072</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ProtocolVersion3">
<MemberSignature Language="C#" Value="public static readonly int ProtocolVersion3 = 196608;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>196608</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,45 +0,0 @@
<Type Name="NpgsqlRowUpdatedEventArgs" FullName="NpgsqlRowUpdatedEventArgs">
<TypeSignature Language="C#" Value="public class NpgsqlRowUpdatedEventArgs : System.Data.Common.RowUpdatedEventArgs" Maintainer="auto" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement />
<Base>
<BaseTypeName>System.Data.Common.RowUpdatedEventArgs</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlRowUpdatedEventArgs (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="dataRow" Type="System.Data.DataRow" />
<Parameter Name="command" Type="System.Data.IDbCommand" />
<Parameter Name="statementType" Type="System.Data.StatementType" />
<Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
</Parameters>
<Docs>
<param name="dataRow">a <see cref="T:System.Data.DataRow" /></param>
<param name="command">a <see cref="T:System.Data.IDbCommand" /></param>
<param name="statementType">a <see cref="T:System.Data.StatementType" /></param>
<param name="tableMapping">a <see cref="T:System.Data.Common.DataTableMapping" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,45 +0,0 @@
<Type Name="NpgsqlRowUpdatingEventArgs" FullName="NpgsqlRowUpdatingEventArgs">
<TypeSignature Language="C#" Value="public class NpgsqlRowUpdatingEventArgs : System.Data.Common.RowUpdatingEventArgs" Maintainer="auto" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyPublicKey>
</AssemblyPublicKey>
<AssemblyVersion>0.6.0.0</AssemblyVersion>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ThreadSafetyStatement />
<Base>
<BaseTypeName>System.Data.Common.RowUpdatingEventArgs</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlRowUpdatingEventArgs (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
<MemberType>Constructor</MemberType>
<ReturnValue />
<Parameters>
<Parameter Name="dataRow" Type="System.Data.DataRow" />
<Parameter Name="command" Type="System.Data.IDbCommand" />
<Parameter Name="statementType" Type="System.Data.StatementType" />
<Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
</Parameters>
<Docs>
<param name="dataRow">a <see cref="T:System.Data.DataRow" /></param>
<param name="command">a <see cref="T:System.Data.IDbCommand" /></param>
<param name="statementType">a <see cref="T:System.Data.StatementType" /></param>
<param name="tableMapping">a <see cref="T:System.Data.Common.DataTableMapping" /></param>
<summary>To be added</summary>
<remarks>To be added</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,249 +0,0 @@
<Type Name="Fastpath" FullName="NpgsqlTypes.Fastpath">
<TypeSignature Language="C#" Value="public class Fastpath" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public Fastpath (Npgsql.NpgsqlConnection conn);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="conn" Type="Npgsql.NpgsqlConnection" />
</Parameters>
<Docs>
<param name="conn">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public Fastpath (Npgsql.NpgsqlConnection conn, System.IO.Stream stream);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="conn" Type="Npgsql.NpgsqlConnection" />
<Parameter Name="stream" Type="System.IO.Stream" />
</Parameters>
<Docs>
<param name="conn">To be added.</param>
<param name="stream">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="AddFunction">
<MemberSignature Language="C#" Value="public void AddFunction (string name, int fnid);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
<Parameter Name="fnid" Type="System.Int32" />
</Parameters>
<Docs>
<param name="name">To be added.</param>
<param name="fnid">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="AddFunctions">
<MemberSignature Language="C#" Value="public void AddFunctions (System.Data.IDataReader rs);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="rs" Type="System.Data.IDataReader" />
</Parameters>
<Docs>
<param name="rs">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="conn">
<MemberSignature Language="C#" Value="protected Npgsql.NpgsqlConnection conn;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>Npgsql.NpgsqlConnection</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="FastpathCall">
<MemberSignature Language="C#" Value="public object FastpathCall (int fnid, bool resulttype, NpgsqlTypes.FastpathArg[] args);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="fnid" Type="System.Int32" />
<Parameter Name="resulttype" Type="System.Boolean" />
<Parameter Name="args" Type="NpgsqlTypes.FastpathArg[]" />
</Parameters>
<Docs>
<param name="fnid">To be added.</param>
<param name="resulttype">To be added.</param>
<param name="args">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="FastpathCall">
<MemberSignature Language="C#" Value="public object FastpathCall (string name, bool resulttype, NpgsqlTypes.FastpathArg[] args);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Object</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
<Parameter Name="resulttype" Type="System.Boolean" />
<Parameter Name="args" Type="NpgsqlTypes.FastpathArg[]" />
</Parameters>
<Docs>
<param name="name">To be added.</param>
<param name="resulttype">To be added.</param>
<param name="args">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="func">
<MemberSignature Language="C#" Value="protected System.Collections.Hashtable func;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Collections.Hashtable</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetData">
<MemberSignature Language="C#" Value="public byte[] GetData (string name, NpgsqlTypes.FastpathArg[] args);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Byte[]</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
<Parameter Name="args" Type="NpgsqlTypes.FastpathArg[]" />
</Parameters>
<Docs>
<param name="name">To be added.</param>
<param name="args">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetID">
<MemberSignature Language="C#" Value="public int GetID (string name);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
</Parameters>
<Docs>
<param name="name">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetInteger">
<MemberSignature Language="C#" Value="public int GetInteger (string name, NpgsqlTypes.FastpathArg[] args);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="name" Type="System.String" />
<Parameter Name="args" Type="NpgsqlTypes.FastpathArg[]" />
</Parameters>
<Docs>
<param name="name">To be added.</param>
<param name="args">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="stream">
<MemberSignature Language="C#" Value="protected System.IO.Stream stream;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.IO.Stream</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,167 +0,0 @@
<Type Name="FastpathArg" FullName="NpgsqlTypes.FastpathArg">
<TypeSignature Language="C#" Value="public class FastpathArg" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public FastpathArg (byte[] bytes);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="bytes" Type="System.Byte[]" />
</Parameters>
<Docs>
<param name="bytes">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public FastpathArg (int value);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="value" Type="System.Int32" />
</Parameters>
<Docs>
<param name="value">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public FastpathArg (string s);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="s" Type="System.String" />
</Parameters>
<Docs>
<param name="s">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public FastpathArg (byte[] buf, int off, int len);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="buf" Type="System.Byte[]" />
<Parameter Name="off" Type="System.Int32" />
<Parameter Name="len" Type="System.Int32" />
</Parameters>
<Docs>
<param name="buf">To be added.</param>
<param name="off">To be added.</param>
<param name="len">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="bytes">
<MemberSignature Language="C#" Value="public byte[] bytes;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Byte[]</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Send">
<MemberSignature Language="C#" Value="public void Send (System.IO.Stream s);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="s" Type="System.IO.Stream" />
</Parameters>
<Docs>
<param name="s">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="SendSize">
<MemberSignature Language="C#" Value="public int SendSize ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="type">
<MemberSignature Language="C#" Value="public bool type;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="value">
<MemberSignature Language="C#" Value="public int value;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,279 +0,0 @@
<Type Name="LargeObject" FullName="NpgsqlTypes.LargeObject">
<TypeSignature Language="C#" Value="public class LargeObject" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public LargeObject (NpgsqlTypes.Fastpath fp, int oid, int mode);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="fp" Type="NpgsqlTypes.Fastpath" />
<Parameter Name="oid" Type="System.Int32" />
<Parameter Name="mode" Type="System.Int32" />
</Parameters>
<Docs>
<param name="fp">To be added.</param>
<param name="oid">To be added.</param>
<param name="mode">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Close">
<MemberSignature Language="C#" Value="public void Close ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="GetOID">
<MemberSignature Language="C#" Value="public int GetOID ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Read">
<MemberSignature Language="C#" Value="public byte[] Read (int len);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Byte[]</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="len" Type="System.Int32" />
</Parameters>
<Docs>
<param name="len">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Read">
<MemberSignature Language="C#" Value="public int Read (byte[] buf, int off, int len);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="buf" Type="System.Byte[]" />
<Parameter Name="off" Type="System.Int32" />
<Parameter Name="len" Type="System.Int32" />
</Parameters>
<Docs>
<param name="buf">To be added.</param>
<param name="off">To be added.</param>
<param name="len">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Seek">
<MemberSignature Language="C#" Value="public void Seek (int pos);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="pos" Type="System.Int32" />
</Parameters>
<Docs>
<param name="pos">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Seek">
<MemberSignature Language="C#" Value="public void Seek (int pos, int refi);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="pos" Type="System.Int32" />
<Parameter Name="refi" Type="System.Int32" />
</Parameters>
<Docs>
<param name="pos">To be added.</param>
<param name="refi">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="SEEK_CUR">
<MemberSignature Language="C#" Value="public const int SEEK_CUR = 1;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>1</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="SEEK_END">
<MemberSignature Language="C#" Value="public const int SEEK_END = 2;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>2</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="SEEK_SET">
<MemberSignature Language="C#" Value="public const int SEEK_SET = 0;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>0</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Size">
<MemberSignature Language="C#" Value="public int Size ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Tell">
<MemberSignature Language="C#" Value="public int Tell ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Write">
<MemberSignature Language="C#" Value="public void Write (byte[] buf);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="buf" Type="System.Byte[]" />
</Parameters>
<Docs>
<param name="buf">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Write">
<MemberSignature Language="C#" Value="public void Write (byte[] buf, int off, int len);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="buf" Type="System.Byte[]" />
<Parameter Name="off" Type="System.Int32" />
<Parameter Name="len" Type="System.Int32" />
</Parameters>
<Docs>
<param name="buf">To be added.</param>
<param name="off">To be added.</param>
<param name="len">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,197 +0,0 @@
<Type Name="LargeObjectManager" FullName="NpgsqlTypes.LargeObjectManager">
<TypeSignature Language="C#" Value="public class LargeObjectManager" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public LargeObjectManager (Npgsql.NpgsqlConnection conn);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="conn" Type="Npgsql.NpgsqlConnection" />
</Parameters>
<Docs>
<param name="conn">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Create">
<MemberSignature Language="C#" Value="public int Create ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Create">
<MemberSignature Language="C#" Value="public int Create (int mode);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="mode" Type="System.Int32" />
</Parameters>
<Docs>
<param name="mode">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Delete">
<MemberSignature Language="C#" Value="public void Delete (int oid);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="oid" Type="System.Int32" />
</Parameters>
<Docs>
<param name="oid">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Open">
<MemberSignature Language="C#" Value="public NpgsqlTypes.LargeObject Open (int oid);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.LargeObject</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="oid" Type="System.Int32" />
</Parameters>
<Docs>
<param name="oid">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Open">
<MemberSignature Language="C#" Value="public NpgsqlTypes.LargeObject Open (int oid, int mode);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.LargeObject</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="oid" Type="System.Int32" />
<Parameter Name="mode" Type="System.Int32" />
</Parameters>
<Docs>
<param name="oid">To be added.</param>
<param name="mode">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="READ">
<MemberSignature Language="C#" Value="public static int READ;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="READWRITE">
<MemberSignature Language="C#" Value="public static int READWRITE;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Unlink">
<MemberSignature Language="C#" Value="public void Unlink (int oid);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Void</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="oid" Type="System.Int32" />
</Parameters>
<Docs>
<param name="oid">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="WRITE">
<MemberSignature Language="C#" Value="public const int WRITE = 131072;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<MemberValue>131072</MemberValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,68 +0,0 @@
<Type Name="NpgsqlBox" FullName="NpgsqlTypes.NpgsqlBox">
<TypeSignature Language="C#" Value="public struct NpgsqlBox" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlBox (NpgsqlTypes.NpgsqlPoint UpperRight, NpgsqlTypes.NpgsqlPoint LowerLeft);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="UpperRight" Type="NpgsqlTypes.NpgsqlPoint" />
<Parameter Name="LowerLeft" Type="NpgsqlTypes.NpgsqlPoint" />
</Parameters>
<Docs>
<param name="UpperRight">To be added.</param>
<param name="LowerLeft">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="LowerLeft">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint LowerLeft { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="UpperRight">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint UpperRight { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,83 +0,0 @@
<Type Name="NpgsqlCircle" FullName="NpgsqlTypes.NpgsqlCircle">
<TypeSignature Language="C#" Value="public struct NpgsqlCircle" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlCircle (NpgsqlTypes.NpgsqlPoint Center, double Radius);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="Center" Type="NpgsqlTypes.NpgsqlPoint" />
<Parameter Name="Radius" Type="System.Double" />
</Parameters>
<Docs>
<param name="Center">To be added.</param>
<param name="Radius">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Center">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint Center;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Radius">
<MemberSignature Language="C#" Value="public double Radius;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Double</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,381 +0,0 @@
<Type Name="NpgsqlDbType" FullName="NpgsqlTypes.NpgsqlDbType">
<TypeSignature Language="C#" Value="public enum NpgsqlDbType" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Enum</BaseTypeName>
</Base>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName="Bigint">
<MemberSignature Language="C#" Value="Bigint" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Bit">
<MemberSignature Language="C#" Value="Bit" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Boolean">
<MemberSignature Language="C#" Value="Boolean" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Box">
<MemberSignature Language="C#" Value="Box" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Bytea">
<MemberSignature Language="C#" Value="Bytea" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Char">
<MemberSignature Language="C#" Value="Char" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Circle">
<MemberSignature Language="C#" Value="Circle" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Date">
<MemberSignature Language="C#" Value="Date" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Double">
<MemberSignature Language="C#" Value="Double" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Inet">
<MemberSignature Language="C#" Value="Inet" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Integer">
<MemberSignature Language="C#" Value="Integer" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Line">
<MemberSignature Language="C#" Value="Line" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="LSeg">
<MemberSignature Language="C#" Value="LSeg" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Money">
<MemberSignature Language="C#" Value="Money" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Numeric">
<MemberSignature Language="C#" Value="Numeric" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Path">
<MemberSignature Language="C#" Value="Path" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Point">
<MemberSignature Language="C#" Value="Point" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Polygon">
<MemberSignature Language="C#" Value="Polygon" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Real">
<MemberSignature Language="C#" Value="Real" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Refcursor">
<MemberSignature Language="C#" Value="Refcursor" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Smallint">
<MemberSignature Language="C#" Value="Smallint" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Text">
<MemberSignature Language="C#" Value="Text" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Time">
<MemberSignature Language="C#" Value="Time" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Timestamp">
<MemberSignature Language="C#" Value="Timestamp" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="TimestampTZ">
<MemberSignature Language="C#" Value="TimestampTZ" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Varchar">
<MemberSignature Language="C#" Value="Varchar" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlDbType</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,135 +0,0 @@
<Type Name="NpgsqlInet" FullName="NpgsqlTypes.NpgsqlInet">
<TypeSignature Language="C#" Value="public struct NpgsqlInet" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlInet (System.Net.IPAddress addr);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="addr" Type="System.Net.IPAddress" />
</Parameters>
<Docs>
<param name="addr">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlInet (string addr);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="addr" Type="System.String" />
</Parameters>
<Docs>
<param name="addr">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlInet (System.Net.IPAddress addr, int mask);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="addr" Type="System.Net.IPAddress" />
<Parameter Name="mask" Type="System.Int32" />
</Parameters>
<Docs>
<param name="addr">To be added.</param>
<param name="mask">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="addr">
<MemberSignature Language="C#" Value="public System.Net.IPAddress addr;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Net.IPAddress</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="mask">
<MemberSignature Language="C#" Value="public int mask;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="op_Implicit">
<MemberSignature Language="C#" Value="public static System.Net.IPAddress op_Implicit (NpgsqlTypes.NpgsqlInet x);" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.Net.IPAddress</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="x" Type="NpgsqlTypes.NpgsqlInet" />
</Parameters>
<Docs>
<param name="x">To be added.</param>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,83 +0,0 @@
<Type Name="NpgsqlLSeg" FullName="NpgsqlTypes.NpgsqlLSeg">
<TypeSignature Language="C#" Value="public struct NpgsqlLSeg" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlLSeg (NpgsqlTypes.NpgsqlPoint Start, NpgsqlTypes.NpgsqlPoint End);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="Start" Type="NpgsqlTypes.NpgsqlPoint" />
<Parameter Name="End" Type="NpgsqlTypes.NpgsqlPoint" />
</Parameters>
<Docs>
<param name="Start">To be added.</param>
<param name="End">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="End">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint End;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Start">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint Start;" />
<MemberType>Field</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="ToString">
<MemberSignature Language="C#" Value="public override string ToString ();" />
<MemberType>Method</MemberType>
<ReturnValue>
<ReturnType>System.String</ReturnType>
</ReturnValue>
<Parameters />
<Docs>
<summary>To be added.</summary>
<returns>To be added.</returns>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,86 +0,0 @@
<Type Name="NpgsqlPath" FullName="NpgsqlTypes.NpgsqlPath">
<TypeSignature Language="C#" Value="public struct NpgsqlPath" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlPath (NpgsqlTypes.NpgsqlPoint[] Points);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="Points" Type="NpgsqlTypes.NpgsqlPoint[]" />
</Parameters>
<Docs>
<param name="Points">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Count">
<MemberSignature Language="C#" Value="public int Count { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint this[int Index] { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">To be added.</param>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Open">
<MemberSignature Language="C#" Value="public bool Open { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Boolean</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,68 +0,0 @@
<Type Name="NpgsqlPoint" FullName="NpgsqlTypes.NpgsqlPoint">
<TypeSignature Language="C#" Value="public struct NpgsqlPoint" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlPoint (float X, float Y);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="X" Type="System.Single" />
<Parameter Name="Y" Type="System.Single" />
</Parameters>
<Docs>
<param name="X">To be added.</param>
<param name="Y">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="X">
<MemberSignature Language="C#" Value="public float X { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Single</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Y">
<MemberSignature Language="C#" Value="public float Y { set; get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Single</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,70 +0,0 @@
<Type Name="NpgsqlPolygon" FullName="NpgsqlTypes.NpgsqlPolygon">
<TypeSignature Language="C#" Value="public struct NpgsqlPolygon" />
<AssemblyInfo>
<AssemblyName>Npgsql</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.ValueType</BaseTypeName>
</Base>
<Interfaces />
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<Members>
<Member MemberName=".ctor">
<MemberSignature Language="C#" Value="public NpgsqlPolygon (NpgsqlTypes.NpgsqlPoint[] Points);" />
<MemberType>Constructor</MemberType>
<Parameters>
<Parameter Name="Points" Type="NpgsqlTypes.NpgsqlPoint[]" />
</Parameters>
<Docs>
<param name="Points">To be added.</param>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Count">
<MemberSignature Language="C#" Value="public int Count { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>System.Int32</ReturnType>
</ReturnValue>
<Docs>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
<Member MemberName="Item">
<MemberSignature Language="C#" Value="public NpgsqlTypes.NpgsqlPoint this[int Index] { get; }" />
<MemberType>Property</MemberType>
<ReturnValue>
<ReturnType>NpgsqlTypes.NpgsqlPoint</ReturnType>
</ReturnValue>
<Parameters>
<Parameter Name="Index" Type="System.Int32" />
</Parameters>
<Docs>
<param name="Index">To be added.</param>
<summary>To be added.</summary>
<value>To be added.</value>
<remarks>To be added.</remarks>
</Docs>
<AssemblyInfo>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
</Member>
</Members>
</Type>
@@ -1,77 +0,0 @@
<Overview>
<Assemblies>
<Assembly Name="Npgsql" Version="2.0.0.0">
<Attributes>
<Attribute>
<AttributeName>System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows=true)</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyTrademark("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyCopyright("The Npgsql Development Team")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyProduct("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyCompany("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyConfiguration("")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyDescription(".Net Data Provider for PostgreSQL")</AttributeName>
</Attribute>
<Attribute>
<AttributeName>System.Reflection.AssemblyTitle("Npgsql - .Net Data Provider for PostgreSQL")</AttributeName>
</Attribute>
</Attributes>
</Assembly>
</Assemblies>
<Remarks>To be added.</Remarks>
<Copyright>To be added.</Copyright>
<Types>
<Namespace Name="">
<Type Name="NpgsqlRowUpdatedEventArgs" Kind="Class" />
<Type Name="NpgsqlRowUpdatingEventArgs" Kind="Class" />
</Namespace>
<Namespace Name="Npgsql">
<Type Name="LogLevel" Kind="Enumeration" />
<Type Name="NoticeEventHandler" Kind="Delegate" />
<Type Name="NotificationEventHandler" Kind="Delegate" />
<Type Name="NpgsqlCommand" Kind="Class" />
<Type Name="NpgsqlCommandBuilder" Kind="Class" />
<Type Name="NpgsqlConnection" Kind="Class" />
<Type Name="NpgsqlDataAdapter" Kind="Class" />
<Type Name="NpgsqlDataReader" Kind="Class" />
<Type Name="NpgsqlError" Kind="Class" />
<Type Name="NpgsqlEventLog" Kind="Class" />
<Type Name="NpgsqlException" Kind="Class" />
<Type Name="NpgsqlNoticeEventArgs" Kind="Class" />
<Type Name="NpgsqlNotificationEventArgs" Kind="Class" />
<Type Name="NpgsqlParameter" Kind="Class" />
<Type Name="NpgsqlParameterCollection" Kind="Class" />
<Type Name="NpgsqlRowUpdatedEventHandler" Kind="Delegate" />
<Type Name="NpgsqlRowUpdatingEventHandler" Kind="Delegate" />
<Type Name="NpgsqlTransaction" Kind="Class" />
<Type Name="ProtocolVersion" Kind="Enumeration" />
<Type Name="ServerVersion" Kind="Class" />
</Namespace>
<Namespace Name="NpgsqlTypes">
<Type Name="Fastpath" Kind="Class" />
<Type Name="FastpathArg" Kind="Class" />
<Type Name="LargeObject" Kind="Class" />
<Type Name="LargeObjectManager" Kind="Class" />
<Type Name="NpgsqlBox" Kind="Structure" />
<Type Name="NpgsqlCircle" Kind="Structure" />
<Type Name="NpgsqlDbType" Kind="Enumeration" />
<Type Name="NpgsqlInet" Kind="Structure" />
<Type Name="NpgsqlLSeg" Kind="Structure" />
<Type Name="NpgsqlPath" Kind="Structure" />
<Type Name="NpgsqlPoint" Kind="Structure" />
<Type Name="NpgsqlPolygon" Kind="Structure" />
</Namespace>
</Types>
<Title>Npgsql</Title>
</Overview>
@@ -1,6 +0,0 @@
<Namespace Name="">
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Namespace>
@@ -1,6 +0,0 @@
<Namespace Name="Npgsql">
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Namespace>
@@ -1,6 +0,0 @@
<Namespace Name="NpgsqlTypes">
<Docs>
<summary>To be added.</summary>
<remarks>To be added.</remarks>
</Docs>
</Namespace>
Loaded 100 of 600 files, more files were not shown because too many files have changed in this diff. Show more