Deleting Single Object¶
Blocking Method¶
Long result = Backendless.Data.Of( "TABLE-NAME" ).Remove( String objectId );
Long result = Backendless.Data.Of( "TABLE-NAME" ).Remove( Dictionary<string, object> entity );
public long Backendless.Data.Of<E>().Remove( String objectId );
public long Backendless.Data.Of<E>().Remove( E entity );
Non-Blocking API¶
void Backendless.Data.Of( "TABLE-NAME" ).Remove( String objectId,
AsyncCallback<long> responder )
void Backendless.Data.Of( "TABLE-NAME" ).Remove( Dictionary<string, object> entity,
AsyncCallback<long> responder )
public void Backendless.Data.Of<E>().Remove( String objectId, AsyncCallback<long> responder )
public void Backendless.Data.Of<E>().Remove( E entity, AsyncCallback<long> responder )
where:
Argument | Description |
---|---|
TABLE-NAME |
Name of the table where the object represented by System.Collections.Generic.Dictionary or objectId will be deleted. |
E |
A .NET class of the data object to delete. |
entity |
.NET object to delete, must be of type E or System.Collections.Generic.Dictionary (depending on the method used). Must contain a value for the objectId property which identifies the object to be deleted. |
responder |
a responder object which will receive a callback when the method successfully deletes the object or if an error occurs. Applies to the non-blocking method only. |
Return Value¶
The blocking method returns the timestamp when the object is deleted. The non-blocking call receives the return value through a callback executed on the AsyncCallback
object.
Example¶
Blocking API¶
``` csharp
public static void DeleteContact()
{
// create new contact object first. Then we will delete it.
Dictionary<String, Object> contact = new Dictionary<String, Object>();
contact.Add( "name", "Jack Daniels" );
contact.Add( "age", 147 );
contact.Add( "phone", "777-777-777" );
contact.Add( "title", "Favorites" );
Dictionary<String, Object> savedContact = Backendless.Persistence.Of( "Contact" ).Save( contact );
// now delete the saved object
Backendless.Persistence.Of( "Contact" ).Remove( savedContact );
}
```
Non-blocking API¶
``` java
public static void DeleteContactAsync()
{
// create new contact object first. Then we will delete it.
Dictionary<String, Object> contact = new Dictionary<String, Object>();
contact.Add( "name", "Jack Daniels" );
contact.Add( "age", 147 );
contact.Add( "phone", "777-777-777" );
contact.Add( "title", "Favorites" );
AsyncCallback<long> deleteObjectCallback = new AsyncCallback<long>(
deletionTime =>
{
System.Console.WriteLine( "object has been deleted" );
},
error =>
{
}
);
AsyncCallback<Dictionary<String, Object>> saveObjectCallback = new AsyncCallback<Dictionary<String, Object>>(
savedContact =>
{
System.Console.WriteLine( "object has been created" );
// now delete the saved object
Backendless.Persistence.Of( "Contact" ).Remove( savedContact, deleteObjectCallback );
},
error =>
{
}
);
Backendless.Persistence.Of( "Contact" ).Save( contact, saveObjectCallback );
}
```
Consider the following class:
package com.sample;
public class Contact
{
private String objectId;
private String name;
private int age;
private String phone;
private String title;
public String getObjectId() {
return objectId;
}
public void setObjectId( String objectId ) {
this.objectId = objectId;
}
public String getName() {
return name;
}
public void setName( String name ) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge( int age ) {
this.age = age;
}
public String getPhone() {
return phone;
}
public void setPhone( String phone ) {
this.phone = phone;
}
public String getTitle() {
return title;
}
public void setTitle( String title ) {
this.title = title;
}
}
Blocking API¶
``` java
public void deleteContact()
{
// make sure to put the initApp call somewhere early on
// in the app - main activity is the best place
// save a new object first, so there is something to delete.
Contact contact = new Contact();
contact.setName( "Jack Daniels" );
contact.setAge( 147 );
contact.setPhone( "777-777-777" );
contact.setTitle( "Favorites" );
Contact savedContact = Backendless.Persistence.save( contact );
// now delete the saved object
Long result = Backendless.Persistence.of( Contact.class ).remove( savedContact );
}
```
Non-Blocking API¶
``` java
public void deleteContact()
{
// put the initApp call somewhere early on in your app, perhaps main activity
// create a new object, so there is something to delete
Contact contact = new Contact();
contact.setName( "Jack Daniels" );
contact.setAge( 147 );
contact.setPhone( "777-777-777" );
contact.setTitle( "Favorites" );
Backendless.Persistence.save( contact, new AsyncCallback<Contact>()
{
public void handleResponse( Contact savedContact )
{
Backendless.Persistence.of( Contact.class ).remove( savedContact,
new AsyncCallback<Long>()
{
public void handleResponse( Long response )
{
// Contact has been deleted. The response is the
// time in milliseconds when the object was deleted
}
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be
// retrieved with fault.getCode()
}
} );
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
}
```