public static GeoLocation CreatePoint(DbGeography location)
 {
     var geoLocation = new GeoLocation();
     geoLocation.Latitude = location.Latitude.Value;
     geoLocation.Longitude = location.Longitude.Value;
     return geoLocation;
 }

        internal SpatialGeography(DbGeography g, ICoordinateSystem coordinateSystem)
        {
            Debug.Assert(g!=null);
            if (g==null)
                throw new ArgumentNullException("g");

            _Geography=g;
            _CoordinateSystem=coordinateSystem;
        }

        public virtual IQueryable<SupplierWithLocation> SuppliersWithinRangeUsingPoint(int? miles, DbGeography location)
        {
            var objectContext = ((IObjectContextAdapter)this).ObjectContext;
            objectContext.MetadataWorkspace.LoadFromAssembly(typeof(SupplierWithLocation).Assembly);

            return objectContext.CreateQuery<SupplierWithLocation>("[SpatialNorthwindContext].[SuppliersWithinRangeUsingPoint](@miles, @location)",
                                                                   new ObjectParameter("miles", miles),
                                                                   new ObjectParameter("location", location));
        }

        public void GetGeographyAsync_calls_GetGeography()
        {
            var mockDbSpatialDataReader = new Mock<DbSpatialDataReader> { CallBase = true };
            var dbGeography = new DbGeography();
            mockDbSpatialDataReader.Setup(m => m.GetGeography(0)).Returns((int ordinal) => dbGeography).Verifiable();

            var task = mockDbSpatialDataReader.Object.GetGeographyAsync(0, CancellationToken.None);

            mockDbSpatialDataReader.Verify(m => m.GetGeography(0), Times.Once());
            Assert.Same(dbGeography, task.Result);
        }

 private static ReadOnlySpatialValues CheckCompatible(DbGeography geographyValue)
 {
     Debug.Assert(geographyValue != null, "Validate geographyValue is non-null before calling CheckCompatible");
     if (geographyValue != null)
     {
         var expectedValue = geographyValue.ProviderValue as ReadOnlySpatialValues;
         if (expectedValue != null)
         {
             return expectedValue;
         }
     }
     throw new ArgumentException(Strings.Spatial_GeographyValueNotCompatibleWithSpatialServices, "geographyValue");
 }

 private static ReadOnlySpatialValues CheckCompatible(DbGeography geographyValue)
 {
     DebugCheck.NotNull(geographyValue);
     if (geographyValue != null)
     {
         var expectedValue = geographyValue.ProviderValue as ReadOnlySpatialValues;
         if (expectedValue != null)
         {
             return expectedValue;
         }
     }
     throw new ArgumentException(Strings.Spatial_GeographyValueNotCompatibleWithSpatialServices, "geographyValue");
 }

 public ParameterModel Geography(
     DbGeography defaultValue = null,
     string defaultValueSql = null,
     string name = null,
     string storeType = null,
     bool outParameter = false)
 {
     return BuildParameter(
         PrimitiveTypeKind.Geography,
         defaultValue,
         defaultValueSql,
         name: name,
         storeType: storeType,
         outParameter: outParameter);
 }

 /// <summary> Computes the symmetric difference of this DbGeography value and another DbGeography value. </summary>
 /// <returns>A new DbGeography value representing the symmetric difference between this geography value and other.</returns>
 /// <param name="other">The geography value for which the symmetric difference with this value should be computed.</param>
 public DbGeography SymmetricDifference(DbGeography other)
 {
     Check.NotNull(other, "other");
     return _spatialProvider.SymmetricDifference(this, other);
 }

 /// <summary> Computes the distance between the closest points in this DbGeography value and another DbGeography value. </summary>
 /// <returns>A double value that specifies the distance between the two closest points in this geography value and other.</returns>
 /// <param name="other">The geography value for which the distance from this value should be computed.</param>
 public double? Distance(DbGeography other)
 {
     Check.NotNull(other, "other");
     return _spatialProvider.Distance(this, other);
 }

 /// <summary> Determines whether this DbGeography is spatially disjoint from the specified DbGeography argument. </summary>
 /// <returns>true if other is disjoint from this geography value; otherwise false.</returns>
 /// <param name="other">The geography value that should be compared with this geography value for disjointness.</param>
 public bool Disjoint(DbGeography other)
 {
     Check.NotNull(other, "other");
     return _spatialProvider.Disjoint(this, other);
 }

 public static Int32? NumRings(DbGeography geographyValue)
 {
     throw new NotSupportedException(Strings.ELinq_DbFunctionDirectCall);
 }

 public static Boolean? Filter(DbGeography geographyValue, DbGeography geographyOther)
 {
     throw new NotSupportedException(Strings.ELinq_DbFunctionDirectCall);
 }

 /// <summary>
 ///     Returns a point element of the given <see cref="T:System.Data.Entity.Spatial.DbGeography" /> value, if it represents a linestring or linear ring.
 /// </summary>
 /// <returns>The point in geographyValue at position index, if it represents a linestring or linear ring; otherwise null.</returns>
 /// <param name="geographyValue">The geography value, which need not represent a linestring or linear ring.</param>
 /// <param name="index">The position within the geography value from which the element should be taken.</param>
 /// <exception cref="ArgumentNullException">
 ///     <paramref name="geographyValue" />
 ///     is null.
 /// </exception>
 /// <exception cref="ArgumentException">
 ///     <paramref name="geographyValue" />
 ///     is not compatible with this spatial services implementation.
 /// </exception>
 public abstract DbGeography PointAt(DbGeography geographyValue, int index);

 /// <summary>
 ///     Returns the number of points in the given <see cref="T:System.Data.Entity.Spatial.DbGeography" /> value, if it represents a linestring or linear ring.
 /// </summary>
 /// <returns>
 ///     The number of points in the given <see cref="T:System.Data.Entity.Spatial.DbGeography" /> value.
 /// </returns>
 /// <param name="geographyValue">The geography value, which need not represent a linestring or linear ring.</param>
 /// <exception cref="ArgumentNullException">
 ///     <paramref name="geographyValue" />
 ///     is null.
 /// </exception>
 /// <exception cref="ArgumentException">
 ///     <paramref name="geographyValue" />
 ///     is not compatible with this spatial services implementation.
 /// </exception>
 public abstract int? GetPointCount(DbGeography geographyValue);

 public static DbGeography BufferWithTolerance(DbGeography geographyValue, Double? distance, Double? tolerance, Boolean? relative)
 {
     throw new NotSupportedException(Strings.ELinq_DbFunctionDirectCall);
 }

 public static string DistanceFromMe(this Center center, DbGeography point)
 {
     return ( (center.Coordinates != null && point!=null )? 
         String.Format("{0:0.##} km", (center.Coordinates.Distance(point)) / 1000) : "-");
 }

 public static DbGeography EnvelopeCenter(DbGeography geographyValue)
 {
     throw new NotSupportedException(Strings.ELinq_DbFunctionDirectCall);
 }

 /// <summary>
 /// Generates SQL to specify a constant geogrpahy default value being set on a column.
 /// This method just generates the actual value, not the SQL to set the default value.
 /// </summary>
 /// <param name="defaultValue"> The value to be set. </param>
 /// <returns> SQL representing the default value. </returns>
 protected virtual string Generate(DbGeography defaultValue)
 {
     return "'" + defaultValue + "'";
 }

 public static Boolean? InstanceOf(DbGeography geographyValue, String geometryTypeName)
 {
     throw new NotSupportedException(Strings.ELinq_DbFunctionDirectCall);
 }

 public static IQueryable<SupplierWithLocation> StaticSuppliersWithinRange(int? miles, DbGeography location)
 {
     throw new NotImplementedException("Should not be called by client code.");
 }